YES 113.91 H-Termination proof of /home/matraf/haskell/eval_FullyBlown_Fast/List.hs
H-Termination of the given Haskell-Program with start terms could successfully be proven:



HASKELL
  ↳ IFR

mainModule List
  ((genericLength :: [a ->  Ratio Int) :: [a ->  Ratio Int)

module List where
  import qualified Maybe
import qualified Prelude

  genericLength :: Num a => [b ->  a
genericLength [] 0
genericLength (_ : l+ genericLength l


module Maybe where
  import qualified List
import qualified Prelude



If Reductions:
The following If expression
if primGEqNatS x y then Succ (primDivNatS (primMinusNatS x y) (Succ y)) else Zero

is transformed to
primDivNatS0 x y True = Succ (primDivNatS (primMinusNatS x y) (Succ y))
primDivNatS0 x y False = Zero

The following If expression
if primGEqNatS x y then primModNatS (primMinusNatS x y) (Succ y) else Succ x

is transformed to
primModNatS0 x y True = primModNatS (primMinusNatS x y) (Succ y)
primModNatS0 x y False = Succ x



↳ HASKELL
  ↳ IFR
HASKELL
      ↳ BR

mainModule List
  ((genericLength :: [a ->  Ratio Int) :: [a ->  Ratio Int)

module List where
  import qualified Maybe
import qualified Prelude

  genericLength :: Num a => [b ->  a
genericLength [] 0
genericLength (_ : l+ genericLength l


module Maybe where
  import qualified List
import qualified Prelude



Replaced joker patterns by fresh variables and removed binding patterns.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
HASKELL
          ↳ COR

mainModule List
  ((genericLength :: [a ->  Ratio Int) :: [a ->  Ratio Int)

module List where
  import qualified Maybe
import qualified Prelude

  genericLength :: Num b => [a ->  b
genericLength [] 0
genericLength (vw : l+ genericLength l


module Maybe where
  import qualified List
import qualified Prelude



Cond Reductions:
The following Function with conditions
gcd' x 0 = x
gcd' x y = gcd' y (x `rem` y)

is transformed to
gcd' x yv = gcd'2 x yv
gcd' x y = gcd'0 x y

gcd'0 x y = gcd' y (x `rem` y)

gcd'1 True x yv = x
gcd'1 yw yx yy = gcd'0 yx yy

gcd'2 x yv = gcd'1 (yv == 0) x yv
gcd'2 yz zu = gcd'0 yz zu

The following Function with conditions
gcd 0 0 = error []
gcd x y = 
gcd' (abs x) (abs y)
where 
gcd' x 0 = x
gcd' x y = gcd' y (x `rem` y)

is transformed to
gcd zv zw = gcd3 zv zw
gcd x y = gcd0 x y

gcd0 x y = 
gcd' (abs x) (abs y)
where 
gcd' x yv = gcd'2 x yv
gcd' x y = gcd'0 x y
gcd'0 x y = gcd' y (x `rem` y)
gcd'1 True x yv = x
gcd'1 yw yx yy = gcd'0 yx yy
gcd'2 x yv = gcd'1 (yv == 0) x yv
gcd'2 yz zu = gcd'0 yz zu

gcd1 True zv zw = error []
gcd1 zx zy zz = gcd0 zy zz

gcd2 True zv zw = gcd1 (zw == 0) zv zw
gcd2 vuu vuv vuw = gcd0 vuv vuw

gcd3 zv zw = gcd2 (zv == 0) zv zw
gcd3 vux vuy = gcd0 vux vuy

The following Function with conditions
absReal x
 | x >= 0
 = x
 | otherwise
 = `negate` x

is transformed to
absReal x = absReal2 x

absReal0 x True = `negate` x

absReal1 x True = x
absReal1 x False = absReal0 x otherwise

absReal2 x = absReal1 x (x >= 0)

The following Function with conditions
undefined 
 | False
 = undefined

is transformed to
undefined  = undefined1

undefined0 True = undefined

undefined1  = undefined0 False

The following Function with conditions
reduce x y
 | y == 0
 = error []
 | otherwise
 = x `quot` d :% (y `quot` d)
where 
d  = gcd x y

is transformed to
reduce x y = reduce2 x y

reduce2 x y = 
reduce1 x y (y == 0)
where 
d  = gcd x y
reduce0 x y True = x `quot` d :% (y `quot` d)
reduce1 x y True = error []
reduce1 x y False = reduce0 x y otherwise



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
HASKELL
              ↳ LetRed

mainModule List
  ((genericLength :: [a ->  Ratio Int) :: [a ->  Ratio Int)

module List where
  import qualified Maybe
import qualified Prelude

  genericLength :: Num b => [a ->  b
genericLength [] 0
genericLength (vw : l+ genericLength l


module Maybe where
  import qualified List
import qualified Prelude



Let/Where Reductions:
The bindings of the following Let/Where expression
reduce1 x y (y == 0)
where 
d  = gcd x y
reduce0 x y True = x `quot` d :% (y `quot` d)
reduce1 x y True = error []
reduce1 x y False = reduce0 x y otherwise

are unpacked to the following functions on top level
reduce2Reduce0 vuz vvu x y True = x `quot` reduce2D vuz vvu :% (y `quot` reduce2D vuz vvu)

reduce2Reduce1 vuz vvu x y True = error []
reduce2Reduce1 vuz vvu x y False = reduce2Reduce0 vuz vvu x y otherwise

reduce2D vuz vvu = gcd vuz vvu

The bindings of the following Let/Where expression
gcd' (abs x) (abs y)
where 
gcd' x yv = gcd'2 x yv
gcd' x y = gcd'0 x y
gcd'0 x y = gcd' y (x `rem` y)
gcd'1 True x yv = x
gcd'1 yw yx yy = gcd'0 yx yy
gcd'2 x yv = gcd'1 (yv == 0) x yv
gcd'2 yz zu = gcd'0 yz zu

are unpacked to the following functions on top level
gcd0Gcd' x yv = gcd0Gcd'2 x yv
gcd0Gcd' x y = gcd0Gcd'0 x y

gcd0Gcd'1 True x yv = x
gcd0Gcd'1 yw yx yy = gcd0Gcd'0 yx yy

gcd0Gcd'0 x y = gcd0Gcd' y (x `rem` y)

gcd0Gcd'2 x yv = gcd0Gcd'1 (yv == 0) x yv
gcd0Gcd'2 yz zu = gcd0Gcd'0 yz zu



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
HASKELL
                  ↳ NumRed

mainModule List
  ((genericLength :: [a ->  Ratio Int) :: [a ->  Ratio Int)

module List where
  import qualified Maybe
import qualified Prelude

  genericLength :: Num b => [a ->  b
genericLength [] 0
genericLength (vw : l+ genericLength l


module Maybe where
  import qualified List
import qualified Prelude



Num Reduction: All numbers are transformed to thier corresponding representation with Pos, Neg, Succ and Zero.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
HASKELL
                      ↳ Narrow

mainModule List
  (genericLength :: [a ->  Ratio Int)

module List where
  import qualified Maybe
import qualified Prelude

  genericLength :: Num a => [b ->  a
genericLength [] fromInt (Pos Zero)
genericLength (vw : lfromInt (Pos (Succ Zero)) + genericLength l


module Maybe where
  import qualified List
import qualified Prelude



Haskell To QDPs


↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primPlusNat(Succ(vvv4500), Succ(vvv41000)) → new_primPlusNat(vvv4500, vvv41000)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primMulNat(Succ(vvv5000), vvv4100) → new_primMulNat(vvv5000, vvv4100)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primRemInt(vvv737, Succ(vvv7380), Succ(vvv7390)) → new_primRemInt(vvv737, vvv7380, vvv7390)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primRemInt0(vvv756, Succ(vvv7570), Succ(vvv7580)) → new_primRemInt0(vvv756, vvv7570, vvv7580)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primRemInt1(vvv809, Succ(vvv8100), Succ(vvv8110)) → new_primRemInt1(vvv809, vvv8100, vvv8110)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primRemInt2(vvv760, Succ(vvv7610), Succ(vvv7620)) → new_primRemInt2(vvv760, vvv7610, vvv7620)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primMinusNatS(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS(vvv75100, vvv7520)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ DependencyGraphProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS0(vvv837, vvv838, Zero, Zero) → new_primDivNatS00(vvv837, vvv838)
new_primDivNatS(Succ(Succ(vvv11500)), Succ(vvv22000)) → new_primDivNatS0(vvv11500, vvv22000, vvv11500, vvv22000)
new_primDivNatS0(vvv837, vvv838, Succ(vvv8390), Succ(vvv8400)) → new_primDivNatS0(vvv837, vvv838, vvv8390, vvv8400)
new_primDivNatS00(vvv837, vvv838) → new_primDivNatS(new_primMinusNatS2(Succ(vvv837), Succ(vvv838)), Succ(vvv838))
new_primDivNatS(Succ(Succ(vvv11500)), Zero) → new_primDivNatS(new_primMinusNatS0(vvv11500), Zero)
new_primDivNatS0(vvv837, vvv838, Succ(vvv8390), Zero) → new_primDivNatS(new_primMinusNatS2(Succ(vvv837), Succ(vvv838)), Succ(vvv838))
new_primDivNatS(Succ(Zero), Zero) → new_primDivNatS(new_primMinusNatS1, Zero)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS1Zero
new_primMinusNatS0(vvv11500) → Succ(vvv11500)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS0(x0)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS1
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 2 SCCs with 1 less node.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
QDP
                                  ↳ UsableRulesProof
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS(Succ(Succ(vvv11500)), Zero) → new_primDivNatS(new_primMinusNatS0(vvv11500), Zero)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS1Zero
new_primMinusNatS0(vvv11500) → Succ(vvv11500)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS0(x0)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS1
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                  ↳ UsableRulesProof
QDP
                                      ↳ QReductionProof
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS(Succ(Succ(vvv11500)), Zero) → new_primDivNatS(new_primMinusNatS0(vvv11500), Zero)

The TRS R consists of the following rules:

new_primMinusNatS0(vvv11500) → Succ(vvv11500)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS0(x0)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS1
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS1
new_primMinusNatS2(Zero, Succ(x0))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
QDP
                                          ↳ RuleRemovalProof
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS(Succ(Succ(vvv11500)), Zero) → new_primDivNatS(new_primMinusNatS0(vvv11500), Zero)

The TRS R consists of the following rules:

new_primMinusNatS0(vvv11500) → Succ(vvv11500)

The set Q consists of the following terms:

new_primMinusNatS0(x0)

We have to consider all minimal (P,Q,R)-chains.
By using the rule removal processor [15] with the following polynomial ordering [25], at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

new_primDivNatS(Succ(Succ(vvv11500)), Zero) → new_primDivNatS(new_primMinusNatS0(vvv11500), Zero)

Strictly oriented rules of the TRS R:

new_primMinusNatS0(vvv11500) → Succ(vvv11500)

Used ordering: POLO with Polynomial interpretation [25]:

POL(Succ(x1)) = 1 + 2·x1   
POL(Zero) = 0   
POL(new_primDivNatS(x1, x2)) = x1 + x2   
POL(new_primMinusNatS0(x1)) = 2 + 2·x1   



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ RuleRemovalProof
QDP
                                              ↳ PisEmptyProof
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
P is empty.
R is empty.
The set Q consists of the following terms:

new_primMinusNatS0(x0)

We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
QDP
                                  ↳ UsableRulesProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS0(vvv837, vvv838, Zero, Zero) → new_primDivNatS00(vvv837, vvv838)
new_primDivNatS0(vvv837, vvv838, Succ(vvv8390), Succ(vvv8400)) → new_primDivNatS0(vvv837, vvv838, vvv8390, vvv8400)
new_primDivNatS(Succ(Succ(vvv11500)), Succ(vvv22000)) → new_primDivNatS0(vvv11500, vvv22000, vvv11500, vvv22000)
new_primDivNatS00(vvv837, vvv838) → new_primDivNatS(new_primMinusNatS2(Succ(vvv837), Succ(vvv838)), Succ(vvv838))
new_primDivNatS0(vvv837, vvv838, Succ(vvv8390), Zero) → new_primDivNatS(new_primMinusNatS2(Succ(vvv837), Succ(vvv838)), Succ(vvv838))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS1Zero
new_primMinusNatS0(vvv11500) → Succ(vvv11500)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS0(x0)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS1
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
QDP
                                      ↳ QReductionProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS0(vvv837, vvv838, Zero, Zero) → new_primDivNatS00(vvv837, vvv838)
new_primDivNatS0(vvv837, vvv838, Succ(vvv8390), Succ(vvv8400)) → new_primDivNatS0(vvv837, vvv838, vvv8390, vvv8400)
new_primDivNatS(Succ(Succ(vvv11500)), Succ(vvv22000)) → new_primDivNatS0(vvv11500, vvv22000, vvv11500, vvv22000)
new_primDivNatS00(vvv837, vvv838) → new_primDivNatS(new_primMinusNatS2(Succ(vvv837), Succ(vvv838)), Succ(vvv838))
new_primDivNatS0(vvv837, vvv838, Succ(vvv8390), Zero) → new_primDivNatS(new_primMinusNatS2(Succ(vvv837), Succ(vvv838)), Succ(vvv838))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS0(x0)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS1
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primMinusNatS0(x0)
new_primMinusNatS1



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
QDP
                                          ↳ Rewriting
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS0(vvv837, vvv838, Zero, Zero) → new_primDivNatS00(vvv837, vvv838)
new_primDivNatS(Succ(Succ(vvv11500)), Succ(vvv22000)) → new_primDivNatS0(vvv11500, vvv22000, vvv11500, vvv22000)
new_primDivNatS0(vvv837, vvv838, Succ(vvv8390), Succ(vvv8400)) → new_primDivNatS0(vvv837, vvv838, vvv8390, vvv8400)
new_primDivNatS00(vvv837, vvv838) → new_primDivNatS(new_primMinusNatS2(Succ(vvv837), Succ(vvv838)), Succ(vvv838))
new_primDivNatS0(vvv837, vvv838, Succ(vvv8390), Zero) → new_primDivNatS(new_primMinusNatS2(Succ(vvv837), Succ(vvv838)), Succ(vvv838))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primDivNatS00(vvv837, vvv838) → new_primDivNatS(new_primMinusNatS2(Succ(vvv837), Succ(vvv838)), Succ(vvv838)) at position [0] we obtained the following new rules:

new_primDivNatS00(vvv837, vvv838) → new_primDivNatS(new_primMinusNatS2(vvv837, vvv838), Succ(vvv838))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
QDP
                                              ↳ Rewriting
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS0(vvv837, vvv838, Zero, Zero) → new_primDivNatS00(vvv837, vvv838)
new_primDivNatS0(vvv837, vvv838, Succ(vvv8390), Succ(vvv8400)) → new_primDivNatS0(vvv837, vvv838, vvv8390, vvv8400)
new_primDivNatS(Succ(Succ(vvv11500)), Succ(vvv22000)) → new_primDivNatS0(vvv11500, vvv22000, vvv11500, vvv22000)
new_primDivNatS00(vvv837, vvv838) → new_primDivNatS(new_primMinusNatS2(vvv837, vvv838), Succ(vvv838))
new_primDivNatS0(vvv837, vvv838, Succ(vvv8390), Zero) → new_primDivNatS(new_primMinusNatS2(Succ(vvv837), Succ(vvv838)), Succ(vvv838))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primDivNatS0(vvv837, vvv838, Succ(vvv8390), Zero) → new_primDivNatS(new_primMinusNatS2(Succ(vvv837), Succ(vvv838)), Succ(vvv838)) at position [0] we obtained the following new rules:

new_primDivNatS0(vvv837, vvv838, Succ(vvv8390), Zero) → new_primDivNatS(new_primMinusNatS2(vvv837, vvv838), Succ(vvv838))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
QDP
                                                  ↳ QDPOrderProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS0(vvv837, vvv838, Zero, Zero) → new_primDivNatS00(vvv837, vvv838)
new_primDivNatS0(vvv837, vvv838, Succ(vvv8390), Zero) → new_primDivNatS(new_primMinusNatS2(vvv837, vvv838), Succ(vvv838))
new_primDivNatS(Succ(Succ(vvv11500)), Succ(vvv22000)) → new_primDivNatS0(vvv11500, vvv22000, vvv11500, vvv22000)
new_primDivNatS0(vvv837, vvv838, Succ(vvv8390), Succ(vvv8400)) → new_primDivNatS0(vvv837, vvv838, vvv8390, vvv8400)
new_primDivNatS00(vvv837, vvv838) → new_primDivNatS(new_primMinusNatS2(vvv837, vvv838), Succ(vvv838))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_primDivNatS0(vvv837, vvv838, Succ(vvv8390), Zero) → new_primDivNatS(new_primMinusNatS2(vvv837, vvv838), Succ(vvv838))
new_primDivNatS(Succ(Succ(vvv11500)), Succ(vvv22000)) → new_primDivNatS0(vvv11500, vvv22000, vvv11500, vvv22000)
new_primDivNatS00(vvv837, vvv838) → new_primDivNatS(new_primMinusNatS2(vvv837, vvv838), Succ(vvv838))
The remaining pairs can at least be oriented weakly.

new_primDivNatS0(vvv837, vvv838, Zero, Zero) → new_primDivNatS00(vvv837, vvv838)
new_primDivNatS0(vvv837, vvv838, Succ(vvv8390), Succ(vvv8400)) → new_primDivNatS0(vvv837, vvv838, vvv8390, vvv8400)
Used ordering: Polynomial interpretation [25]:

POL(Succ(x1)) = 1 + x1   
POL(Zero) = 0   
POL(new_primDivNatS(x1, x2)) = x1   
POL(new_primDivNatS0(x1, x2, x3, x4)) = 1 + x1   
POL(new_primDivNatS00(x1, x2)) = 1 + x1   
POL(new_primMinusNatS2(x1, x2)) = x1   

The following usable rules [17] were oriented:

new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ QDPOrderProof
QDP
                                                      ↳ DependencyGraphProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS0(vvv837, vvv838, Zero, Zero) → new_primDivNatS00(vvv837, vvv838)
new_primDivNatS0(vvv837, vvv838, Succ(vvv8390), Succ(vvv8400)) → new_primDivNatS0(vvv837, vvv838, vvv8390, vvv8400)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ QDPOrderProof
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
QDP
                                                          ↳ UsableRulesProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS0(vvv837, vvv838, Succ(vvv8390), Succ(vvv8400)) → new_primDivNatS0(vvv837, vvv838, vvv8390, vvv8400)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ QDPOrderProof
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ UsableRulesProof
QDP
                                                              ↳ QReductionProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS0(vvv837, vvv838, Succ(vvv8390), Succ(vvv8400)) → new_primDivNatS0(vvv837, vvv838, vvv8390, vvv8400)

R is empty.
The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ QDPOrderProof
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ UsableRulesProof
                                                            ↳ QDP
                                                              ↳ QReductionProof
QDP
                                                                  ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS0(vvv837, vvv838, Succ(vvv8390), Succ(vvv8400)) → new_primDivNatS0(vvv837, vvv838, vvv8390, vvv8400)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt(vvv652, vvv653, Succ(vvv6540), Succ(vvv6550)) → new_primQuotInt(vvv652, vvv653, vvv6540, vvv6550)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt0(vvv638, vvv639, Succ(vvv6400), Succ(vvv6410)) → new_primQuotInt0(vvv638, vvv639, vvv6400, vvv6410)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ DependencyGraphProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt49(vvv1285, Zero, Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt55(vvv1285, vvv1288, vvv1289)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Zero, vvv1025, vvv1038) → new_primQuotInt17(vvv1020, new_primMinusNatS2(Succ(vvv103900), Zero), Zero, vvv1025, new_primMinusNatS2(Succ(vvv103900), Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Zero, vvv1217) → new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217)
new_primQuotInt42(vvv51, Succ(vvv473000), Zero, vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt42(vvv51, Zero, Succ(vvv295000), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt2(vvv1293, vvv1296, vvv1297, vvv1314) → new_primQuotInt4(vvv1293, vvv1296, vvv1297, vvv1314)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt45(vvv1068, Zero, vvv1070, Pos(Succ(vvv107300)), vvv1083) → new_primQuotInt35(vvv1068, new_rem2(vvv1070))
new_primQuotInt18(vvv51, Pos(Zero), Neg(Succ(vvv29500)), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt18(vvv51, Neg(Zero), Pos(Succ(vvv29500)), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt18(vvv51, Pos(Succ(Succ(vvv473000))), Pos(Succ(Succ(vvv295000))), vvv472) → new_primQuotInt42(vvv51, vvv473000, vvv295000, vvv472)
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt45(vvv1068, Zero, vvv1070, Neg(Succ(vvv107300)), vvv1083) → new_primQuotInt51(vvv1068, vvv1070)
new_primQuotInt32(vvv1265, vvv1268, vvv1269, vvv1291) → new_primQuotInt39(vvv1265, vvv1268, vvv1269, vvv1291)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Succ(vvv101800)), vvv1036) → new_primQuotInt1(vvv1013, Zero, vvv101800, Succ(vvv10150), Zero)
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Pos(vvv10730), vvv1083) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, new_fromInt)
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, new_fromInt)
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Succ(vvv12230), vvv1224) → new_primQuotInt6(vvv1219, vvv1220, vvv1221, vvv12220, vvv12230, vvv1224)
new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, new_fromInt)
new_primQuotInt44(vvv51, Pos(Zero), vvv504) → new_primQuotInt13(vvv51, new_error, vvv504, new_error)
new_primQuotInt41(vvv1068, vvv1094, vvv1097) → new_primQuotInt18(vvv1068, vvv1094, vvv1097, vvv1094)
new_primQuotInt13(vvv46, Pos(Succ(Zero)), Pos(Succ(Succ(vvv309000))), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt13(vvv46, Pos(Succ(Succ(vvv475000))), Pos(Succ(Zero)), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Neg(vvv10250), vvv1038) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt29(vvv699, vvv700, vvv703, vvv704) → new_primQuotInt30(vvv699, Succ(vvv700), vvv703, vvv704, Succ(vvv700))
new_primQuotInt33(vvv1265, Succ(vvv12660), Zero, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, new_fromInt)
new_primQuotInt19(vvv46, Pos(Zero), vvv506) → new_primQuotInt13(vvv46, new_error, vvv506, new_error)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Succ(vvv12160), vvv1217) → new_primQuotInt47(vvv1212, vvv1213, vvv1214, vvv12150, vvv12160, vvv1217)
new_primQuotInt15(vvv46, vvv474) → new_primQuotInt16(vvv46, vvv474, new_fromInt)
new_primQuotInt18(vvv51, Neg(Succ(vvv47300)), Neg(Succ(vvv29500)), vvv472) → new_primQuotInt42(vvv51, vvv47300, vvv29500, vvv472)
new_primQuotInt44(vvv51, Neg(Zero), vvv504) → new_primQuotInt18(vvv51, new_error, vvv504, new_error)
new_primQuotInt16(vvv46, Pos(Succ(vvv47400)), vvv506) → new_primQuotInt5(vvv46, Zero, vvv47400, vvv506, Zero)
new_primQuotInt16(vvv46, Pos(Zero), vvv506) → new_primQuotInt13(vvv46, new_error, vvv506, new_error)
new_primQuotInt14(vvv46, Succ(vvv475000), Zero, vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt14(vvv46, Zero, Succ(vvv309000), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt5(vvv1013, Succ(Zero), Zero, vvv1018, vvv1036) → new_primQuotInt5(vvv1013, new_primMinusNatS2(Zero, Zero), Zero, vvv1018, new_primMinusNatS2(Zero, Zero))
new_primQuotInt24(vvv1020, vvv1022) → new_primQuotInt8(vvv1020, new_rem0(vvv1022))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Zero, vvv1224) → new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt5(vvv1013, Zero, vvv1015, Pos(Succ(vvv101800)), vvv1036) → new_primQuotInt8(vvv1013, new_rem(vvv1015))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Neg(Succ(vvv121700))) → new_primQuotInt49(vvv1212, Succ(vvv1213), vvv121700, vvv1214, Succ(vvv1213))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), new_fromInt)
new_primQuotInt43(vvv51, vvv472) → new_primQuotInt44(vvv51, vvv472, new_fromInt)
new_primQuotInt1(vvv1293, Zero, Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt3(vvv1293, vvv1296, vvv1297)
new_primQuotInt13(vvv46, Neg(Succ(vvv47500)), Neg(Zero), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt13(vvv46, Neg(Zero), Neg(Succ(vvv30900)), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), new_fromInt)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Neg(vvv12240)) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), new_fromInt)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Zero, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Zero)) → new_primQuotInt10(vvv1219, vvv1221, vvv1220)
new_primQuotInt48(vvv1285, vvv1288, vvv1289, vvv1307) → new_primQuotInt54(vvv1285, vvv1288, vvv1289, vvv1307)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Zero)) → new_primQuotInt37(vvv1186, vvv1188, vvv1187)
new_primQuotInt33(vvv1265, Zero, Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt40(vvv1265, vvv1268, vvv1269)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt7(vvv1013, vvv10150) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, new_fromInt)
new_primQuotInt30(vvv1028, Succ(Zero), Zero, vvv1033, vvv1047) → new_primQuotInt30(vvv1028, new_primMinusNatS2(Zero, Zero), Zero, vvv1033, new_primMinusNatS2(Zero, Zero))
new_primQuotInt36(vvv1028, vvv1030) → new_primQuotInt35(vvv1028, new_rem1(vvv1030))
new_primQuotInt13(vvv46, Pos(Succ(vvv47500)), Neg(vvv3090), vvv474) → new_primQuotInt16(vvv46, vvv474, new_fromInt)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt21(vvv1020, Zero, vvv102500, Succ(vvv10220), Zero)
new_primQuotInt13(vvv46, Neg(Zero), Pos(Succ(vvv30900)), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt13(vvv46, Pos(Zero), Neg(Succ(vvv30900)), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt19(vvv46, Neg(Succ(vvv47400)), vvv506) → new_primQuotInt17(vvv46, Zero, vvv47400, vvv506, Zero)
new_primQuotInt49(vvv1285, Succ(vvv12860), Zero, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, new_fromInt)
new_primQuotInt21(vvv1300, Zero, Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt28(vvv1300, vvv1303, vvv1304)
new_primQuotInt46(vvv51, Pos(Succ(vvv47200)), vvv504) → new_primQuotInt30(vvv51, Zero, vvv47200, vvv504, Zero)
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Neg(Zero), vvv1083) → new_primQuotInt50(vvv1068, vvv10700)
new_primQuotInt45(vvv1068, Succ(Succ(vvv108400)), Zero, vvv1073, vvv1083) → new_primQuotInt45(vvv1068, new_primMinusNatS2(Succ(vvv108400), Zero), Zero, vvv1073, new_primMinusNatS2(Succ(vvv108400), Zero))
new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Zero, vvv1018, vvv1036) → new_primQuotInt5(vvv1013, new_primMinusNatS2(Succ(vvv103700), Zero), Zero, vvv1018, new_primMinusNatS2(Succ(vvv103700), Zero))
new_primQuotInt13(vvv46, Neg(Succ(vvv47500)), Neg(Succ(vvv30900)), vvv474) → new_primQuotInt14(vvv46, vvv47500, vvv30900, vvv474)
new_primQuotInt26(vvv1300, vvv1303, vvv1304, vvv1319) → new_primQuotInt29(vvv1300, vvv1303, vvv1304, vvv1319)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Succ(vvv119100))) → new_primQuotInt33(vvv1186, Succ(vvv1187), vvv119100, vvv1188, Succ(vvv1187))
new_primQuotInt16(vvv46, Neg(Succ(vvv47400)), vvv506) → new_primQuotInt17(vvv46, Zero, vvv47400, vvv506, Zero)
new_primQuotInt45(vvv1068, Succ(Zero), Zero, vvv1073, vvv1083) → new_primQuotInt45(vvv1068, new_primMinusNatS2(Zero, Zero), Zero, vvv1073, new_primMinusNatS2(Zero, Zero))
new_primQuotInt16(vvv46, Neg(Zero), vvv506) → new_primQuotInt18(vvv46, new_error, vvv506, new_error)
new_primQuotInt17(vvv1020, Zero, vvv1022, Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt8(vvv1020, new_rem0(vvv1022))
new_primQuotInt3(vvv1293, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, new_fromInt)
new_primQuotInt1(vvv1293, Succ(vvv12940), Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt1(vvv1293, vvv12940, vvv12950, vvv1296, vvv1297)
new_primQuotInt1(vvv1293, Succ(vvv12940), Zero, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, new_fromInt)
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Zero), vvv1036) → new_primQuotInt7(vvv1013, vvv10150)
new_primQuotInt19(vvv46, Neg(Zero), vvv506) → new_primQuotInt18(vvv46, new_error, vvv506, new_error)
new_primQuotInt35(vvv1068, vvv1094) → new_primQuotInt41(vvv1068, vvv1094, new_fromInt)
new_primQuotInt14(vvv46, Succ(vvv475000), Succ(vvv309000), vvv474) → new_primQuotInt14(vvv46, vvv475000, vvv309000, vvv474)
new_primQuotInt40(vvv1265, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, new_fromInt)
new_primQuotInt13(vvv46, Pos(Succ(Succ(vvv475000))), Pos(Succ(Succ(vvv309000))), vvv474) → new_primQuotInt14(vvv46, vvv475000, vvv309000, vvv474)
new_primQuotInt34(vvv1028, vvv10300) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, new_fromInt)
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Zero, vvv1033, vvv1047) → new_primQuotInt30(vvv1028, new_primMinusNatS2(Succ(vvv104800), Zero), Zero, vvv1033, new_primMinusNatS2(Succ(vvv104800), Zero))
new_primQuotInt17(vvv1020, Succ(Zero), Zero, vvv1025, vvv1038) → new_primQuotInt17(vvv1020, new_primMinusNatS2(Zero, Zero), Zero, vvv1025, new_primMinusNatS2(Zero, Zero))
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Pos(vvv10330), vvv1047) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, new_fromInt)
new_primQuotInt8(vvv1013, vvv1054) → new_primQuotInt12(vvv1013, vvv1054, new_fromInt)
new_primQuotInt45(vvv1068, Succ(Succ(vvv108400)), Succ(vvv10700), vvv1073, vvv1083) → new_primQuotInt47(vvv1068, vvv108400, Succ(vvv10700), vvv108400, vvv10700, vvv1073)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Neg(Zero)) → new_primQuotInt52(vvv1212, vvv1214, vvv1213)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Pos(vvv12170)) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), new_fromInt)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt51(vvv1068, vvv1070) → new_primQuotInt35(vvv1068, new_rem2(vvv1070))
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Neg(vvv10180), vvv1036) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, new_fromInt)
new_primQuotInt5(vvv1013, Zero, vvv1015, Neg(Succ(vvv101800)), vvv1036) → new_primQuotInt9(vvv1013, vvv1015)
new_primQuotInt50(vvv1068, vvv10700) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, new_fromInt)
new_primQuotInt39(vvv436, vvv4410, vvv437, vvv479) → new_primQuotInt17(vvv436, Succ(vvv4410), vvv437, vvv479, Succ(vvv4410))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Neg(vvv12310)) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), new_fromInt)
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), new_fromInt)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Succ(vvv123100))) → new_primQuotInt21(vvv1226, Succ(vvv1227), vvv123100, vvv1228, Succ(vvv1227))
new_primQuotInt44(vvv51, Neg(Succ(vvv47200)), vvv504) → new_primQuotInt45(vvv51, Zero, vvv47200, vvv504, Zero)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Zero), vvv1047) → new_primQuotInt34(vvv1028, vvv10300)
new_primQuotInt54(vvv802, vvv803, vvv806, vvv807) → new_primQuotInt45(vvv802, Succ(vvv803), vvv806, vvv807, Succ(vvv803))
new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, new_fromInt)
new_primQuotInt18(vvv51, Neg(Succ(vvv47300)), Neg(Zero), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt18(vvv51, Neg(Zero), Neg(Succ(vvv29500)), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt46(vvv51, Neg(Zero), vvv504) → new_primQuotInt18(vvv51, new_error, vvv504, new_error)
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt9(vvv1013, vvv1015) → new_primQuotInt8(vvv1013, new_rem(vvv1015))
new_primQuotInt13(vvv46, Neg(Succ(vvv47500)), Pos(vvv3090), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Zero, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Succ(vvv103300)), vvv1047) → new_primQuotInt33(vvv1028, Zero, vvv103300, Succ(vvv10300), Zero)
new_primQuotInt17(vvv1020, Zero, vvv1022, Neg(Succ(vvv102500)), vvv1038) → new_primQuotInt24(vvv1020, vvv1022)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt30(vvv1028, Zero, vvv1030, Pos(Succ(vvv103300)), vvv1047) → new_primQuotInt35(vvv1028, new_rem1(vvv1030))
new_primQuotInt37(vvv1186, vvv1188, vvv1187) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), new_fromInt)
new_primQuotInt30(vvv1028, Zero, vvv1030, Neg(Succ(vvv103300)), vvv1047) → new_primQuotInt36(vvv1028, vvv1030)
new_primQuotInt18(vvv51, Pos(Succ(vvv47300)), Pos(Zero), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt18(vvv51, Pos(Zero), Pos(Succ(vvv29500)), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt18(vvv51, Pos(Succ(vvv47300)), Neg(vvv2950), vvv472) → new_primQuotInt44(vvv51, vvv472, new_fromInt)
new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Succ(vvv10150), vvv1018, vvv1036) → new_primQuotInt6(vvv1013, vvv103700, Succ(vvv10150), vvv103700, vvv10150, vvv1018)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt12(vvv1013, vvv1054, vvv1058) → new_primQuotInt13(vvv1013, vvv1054, vvv1058, vvv1054)
new_primQuotInt18(vvv51, Pos(Succ(Succ(vvv473000))), Pos(Succ(Zero)), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt18(vvv51, Pos(Succ(Zero)), Pos(Succ(Succ(vvv295000))), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt44(vvv51, Pos(Succ(vvv47200)), vvv504) → new_primQuotInt30(vvv51, Zero, vvv47200, vvv504, Zero)
new_primQuotInt46(vvv51, Pos(Zero), vvv504) → new_primQuotInt13(vvv51, new_error, vvv504, new_error)
new_primQuotInt33(vvv1265, Succ(vvv12660), Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt33(vvv1265, vvv12660, vvv12670, vvv1268, vvv1269)
new_primQuotInt42(vvv51, Succ(vvv473000), Succ(vvv295000), vvv472) → new_primQuotInt42(vvv51, vvv473000, vvv295000, vvv472)
new_primQuotInt4(vvv51, vvv2240, vvv520, vvv303) → new_primQuotInt5(vvv51, Succ(vvv2240), vvv520, vvv303, Succ(vvv2240))
new_primQuotInt46(vvv51, Neg(Succ(vvv47200)), vvv504) → new_primQuotInt45(vvv51, Zero, vvv47200, vvv504, Zero)
new_primQuotInt52(vvv1212, vvv1214, vvv1213) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), new_fromInt)
new_primQuotInt55(vvv1285, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, new_fromInt)
new_primQuotInt49(vvv1285, Succ(vvv12860), Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt49(vvv1285, vvv12860, vvv12870, vvv1288, vvv1289)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Succ(vvv122400))) → new_primQuotInt1(vvv1219, Succ(vvv1220), vvv122400, vvv1221, Succ(vvv1220))
new_primQuotInt18(vvv51, Neg(Succ(vvv47300)), Pos(vvv2950), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt19(vvv46, Pos(Succ(vvv47400)), vvv506) → new_primQuotInt5(vvv46, Zero, vvv47400, vvv506, Zero)
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Neg(Succ(vvv107300)), vvv1083) → new_primQuotInt49(vvv1068, Zero, vvv107300, Succ(vvv10700), Zero)
new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)
new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt13(vvv46, Pos(Succ(vvv47500)), Pos(Zero), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt13(vvv46, Pos(Zero), Pos(Succ(vvv30900)), vvv474) → new_primQuotInt15(vvv46, vvv474)

The TRS R consists of the following rules:

new_primRemInt3(vvv46800) → new_error
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_rem1(vvv1030) → new_primRemInt4(vvv1030)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_errorerror([])
new_rem(vvv1160) → new_primRemInt5(vvv1160)
new_rem0(vvv1008) → new_primRemInt3(vvv1008)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Zero) → Zero
new_rem2(vvv47200) → new_primRemInt6(vvv47200)
new_primRemInt6(vvv47200) → new_error
new_fromIntPos(Zero)
new_primRemInt5(vvv2200) → new_error
new_primRemInt4(vvv2200) → new_error

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 9 SCCs with 16 less nodes.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
QDP
                                  ↳ UsableRulesProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt16(vvv46, Pos(Succ(vvv47400)), vvv506) → new_primQuotInt5(vvv46, Zero, vvv47400, vvv506, Zero)
new_primQuotInt14(vvv46, Zero, Succ(vvv309000), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt14(vvv46, Succ(vvv475000), Zero, vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt9(vvv1013, vvv1015) → new_primQuotInt8(vvv1013, new_rem(vvv1015))
new_primQuotInt13(vvv46, Neg(Succ(vvv47500)), Neg(Succ(vvv30900)), vvv474) → new_primQuotInt14(vvv46, vvv47500, vvv30900, vvv474)
new_primQuotInt13(vvv46, Neg(Succ(vvv47500)), Pos(vvv3090), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt16(vvv46, Neg(Succ(vvv47400)), vvv506) → new_primQuotInt17(vvv46, Zero, vvv47400, vvv506, Zero)
new_primQuotInt24(vvv1020, vvv1022) → new_primQuotInt8(vvv1020, new_rem0(vvv1022))
new_primQuotInt17(vvv1020, Zero, vvv1022, Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt8(vvv1020, new_rem0(vvv1022))
new_primQuotInt5(vvv1013, Zero, vvv1015, Pos(Succ(vvv101800)), vvv1036) → new_primQuotInt8(vvv1013, new_rem(vvv1015))
new_primQuotInt17(vvv1020, Zero, vvv1022, Neg(Succ(vvv102500)), vvv1038) → new_primQuotInt24(vvv1020, vvv1022)
new_primQuotInt13(vvv46, Neg(Succ(vvv47500)), Neg(Zero), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt13(vvv46, Neg(Zero), Neg(Succ(vvv30900)), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt12(vvv1013, vvv1054, vvv1058) → new_primQuotInt13(vvv1013, vvv1054, vvv1058, vvv1054)
new_primQuotInt14(vvv46, Succ(vvv475000), Succ(vvv309000), vvv474) → new_primQuotInt14(vvv46, vvv475000, vvv309000, vvv474)
new_primQuotInt13(vvv46, Pos(Succ(Succ(vvv475000))), Pos(Succ(Succ(vvv309000))), vvv474) → new_primQuotInt14(vvv46, vvv475000, vvv309000, vvv474)
new_primQuotInt13(vvv46, Pos(Succ(Succ(vvv475000))), Pos(Succ(Zero)), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt13(vvv46, Pos(Succ(Zero)), Pos(Succ(Succ(vvv309000))), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt13(vvv46, Pos(Succ(vvv47500)), Neg(vvv3090), vvv474) → new_primQuotInt16(vvv46, vvv474, new_fromInt)
new_primQuotInt8(vvv1013, vvv1054) → new_primQuotInt12(vvv1013, vvv1054, new_fromInt)
new_primQuotInt13(vvv46, Neg(Zero), Pos(Succ(vvv30900)), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt13(vvv46, Pos(Zero), Neg(Succ(vvv30900)), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt15(vvv46, vvv474) → new_primQuotInt16(vvv46, vvv474, new_fromInt)
new_primQuotInt5(vvv1013, Zero, vvv1015, Neg(Succ(vvv101800)), vvv1036) → new_primQuotInt9(vvv1013, vvv1015)
new_primQuotInt13(vvv46, Pos(Zero), Pos(Succ(vvv30900)), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt13(vvv46, Pos(Succ(vvv47500)), Pos(Zero), vvv474) → new_primQuotInt15(vvv46, vvv474)

The TRS R consists of the following rules:

new_primRemInt3(vvv46800) → new_error
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_rem1(vvv1030) → new_primRemInt4(vvv1030)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_errorerror([])
new_rem(vvv1160) → new_primRemInt5(vvv1160)
new_rem0(vvv1008) → new_primRemInt3(vvv1008)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Zero) → Zero
new_rem2(vvv47200) → new_primRemInt6(vvv47200)
new_primRemInt6(vvv47200) → new_error
new_fromIntPos(Zero)
new_primRemInt5(vvv2200) → new_error
new_primRemInt4(vvv2200) → new_error

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                  ↳ UsableRulesProof
QDP
                                      ↳ QReductionProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt16(vvv46, Pos(Succ(vvv47400)), vvv506) → new_primQuotInt5(vvv46, Zero, vvv47400, vvv506, Zero)
new_primQuotInt14(vvv46, Zero, Succ(vvv309000), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt14(vvv46, Succ(vvv475000), Zero, vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt9(vvv1013, vvv1015) → new_primQuotInt8(vvv1013, new_rem(vvv1015))
new_primQuotInt13(vvv46, Neg(Succ(vvv47500)), Neg(Succ(vvv30900)), vvv474) → new_primQuotInt14(vvv46, vvv47500, vvv30900, vvv474)
new_primQuotInt13(vvv46, Neg(Succ(vvv47500)), Pos(vvv3090), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt16(vvv46, Neg(Succ(vvv47400)), vvv506) → new_primQuotInt17(vvv46, Zero, vvv47400, vvv506, Zero)
new_primQuotInt24(vvv1020, vvv1022) → new_primQuotInt8(vvv1020, new_rem0(vvv1022))
new_primQuotInt17(vvv1020, Zero, vvv1022, Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt8(vvv1020, new_rem0(vvv1022))
new_primQuotInt5(vvv1013, Zero, vvv1015, Pos(Succ(vvv101800)), vvv1036) → new_primQuotInt8(vvv1013, new_rem(vvv1015))
new_primQuotInt17(vvv1020, Zero, vvv1022, Neg(Succ(vvv102500)), vvv1038) → new_primQuotInt24(vvv1020, vvv1022)
new_primQuotInt13(vvv46, Neg(Succ(vvv47500)), Neg(Zero), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt13(vvv46, Neg(Zero), Neg(Succ(vvv30900)), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt12(vvv1013, vvv1054, vvv1058) → new_primQuotInt13(vvv1013, vvv1054, vvv1058, vvv1054)
new_primQuotInt14(vvv46, Succ(vvv475000), Succ(vvv309000), vvv474) → new_primQuotInt14(vvv46, vvv475000, vvv309000, vvv474)
new_primQuotInt13(vvv46, Pos(Succ(Succ(vvv475000))), Pos(Succ(Succ(vvv309000))), vvv474) → new_primQuotInt14(vvv46, vvv475000, vvv309000, vvv474)
new_primQuotInt13(vvv46, Pos(Succ(Succ(vvv475000))), Pos(Succ(Zero)), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt13(vvv46, Pos(Succ(Zero)), Pos(Succ(Succ(vvv309000))), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt13(vvv46, Pos(Succ(vvv47500)), Neg(vvv3090), vvv474) → new_primQuotInt16(vvv46, vvv474, new_fromInt)
new_primQuotInt8(vvv1013, vvv1054) → new_primQuotInt12(vvv1013, vvv1054, new_fromInt)
new_primQuotInt13(vvv46, Neg(Zero), Pos(Succ(vvv30900)), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt13(vvv46, Pos(Zero), Neg(Succ(vvv30900)), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt15(vvv46, vvv474) → new_primQuotInt16(vvv46, vvv474, new_fromInt)
new_primQuotInt5(vvv1013, Zero, vvv1015, Neg(Succ(vvv101800)), vvv1036) → new_primQuotInt9(vvv1013, vvv1015)
new_primQuotInt13(vvv46, Pos(Zero), Pos(Succ(vvv30900)), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt13(vvv46, Pos(Succ(vvv47500)), Pos(Zero), vvv474) → new_primQuotInt15(vvv46, vvv474)

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_rem(vvv1160) → new_primRemInt5(vvv1160)
new_primRemInt5(vvv2200) → new_error
new_errorerror([])
new_rem0(vvv1008) → new_primRemInt3(vvv1008)
new_primRemInt3(vvv46800) → new_error

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primMinusNatS2(Succ(x0), Zero)
new_rem2(x0)
new_rem1(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt4(x0)



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
QDP
                                          ↳ UsableRulesReductionPairsProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt16(vvv46, Pos(Succ(vvv47400)), vvv506) → new_primQuotInt5(vvv46, Zero, vvv47400, vvv506, Zero)
new_primQuotInt14(vvv46, Succ(vvv475000), Zero, vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt14(vvv46, Zero, Succ(vvv309000), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt13(vvv46, Neg(Succ(vvv47500)), Neg(Succ(vvv30900)), vvv474) → new_primQuotInt14(vvv46, vvv47500, vvv30900, vvv474)
new_primQuotInt9(vvv1013, vvv1015) → new_primQuotInt8(vvv1013, new_rem(vvv1015))
new_primQuotInt13(vvv46, Neg(Succ(vvv47500)), Pos(vvv3090), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt24(vvv1020, vvv1022) → new_primQuotInt8(vvv1020, new_rem0(vvv1022))
new_primQuotInt16(vvv46, Neg(Succ(vvv47400)), vvv506) → new_primQuotInt17(vvv46, Zero, vvv47400, vvv506, Zero)
new_primQuotInt17(vvv1020, Zero, vvv1022, Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt8(vvv1020, new_rem0(vvv1022))
new_primQuotInt5(vvv1013, Zero, vvv1015, Pos(Succ(vvv101800)), vvv1036) → new_primQuotInt8(vvv1013, new_rem(vvv1015))
new_primQuotInt17(vvv1020, Zero, vvv1022, Neg(Succ(vvv102500)), vvv1038) → new_primQuotInt24(vvv1020, vvv1022)
new_primQuotInt13(vvv46, Neg(Zero), Neg(Succ(vvv30900)), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt13(vvv46, Neg(Succ(vvv47500)), Neg(Zero), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt12(vvv1013, vvv1054, vvv1058) → new_primQuotInt13(vvv1013, vvv1054, vvv1058, vvv1054)
new_primQuotInt14(vvv46, Succ(vvv475000), Succ(vvv309000), vvv474) → new_primQuotInt14(vvv46, vvv475000, vvv309000, vvv474)
new_primQuotInt13(vvv46, Pos(Succ(Succ(vvv475000))), Pos(Succ(Succ(vvv309000))), vvv474) → new_primQuotInt14(vvv46, vvv475000, vvv309000, vvv474)
new_primQuotInt13(vvv46, Pos(Succ(Succ(vvv475000))), Pos(Succ(Zero)), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt13(vvv46, Pos(Succ(Zero)), Pos(Succ(Succ(vvv309000))), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt13(vvv46, Pos(Succ(vvv47500)), Neg(vvv3090), vvv474) → new_primQuotInt16(vvv46, vvv474, new_fromInt)
new_primQuotInt8(vvv1013, vvv1054) → new_primQuotInt12(vvv1013, vvv1054, new_fromInt)
new_primQuotInt13(vvv46, Neg(Zero), Pos(Succ(vvv30900)), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt13(vvv46, Pos(Zero), Neg(Succ(vvv30900)), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt15(vvv46, vvv474) → new_primQuotInt16(vvv46, vvv474, new_fromInt)
new_primQuotInt5(vvv1013, Zero, vvv1015, Neg(Succ(vvv101800)), vvv1036) → new_primQuotInt9(vvv1013, vvv1015)
new_primQuotInt13(vvv46, Pos(Succ(vvv47500)), Pos(Zero), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt13(vvv46, Pos(Zero), Pos(Succ(vvv30900)), vvv474) → new_primQuotInt15(vvv46, vvv474)

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_rem(vvv1160) → new_primRemInt5(vvv1160)
new_primRemInt5(vvv2200) → new_error
new_errorerror([])
new_rem0(vvv1008) → new_primRemInt3(vvv1008)
new_primRemInt3(vvv46800) → new_error

The set Q consists of the following terms:

new_rem0(x0)
new_rem(x0)
new_error
new_fromInt
new_primRemInt3(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
By using the usable rules with reduction pair processor [15] with a polynomial ordering [25], all dependency pairs and the corresponding usable rules [17] can be oriented non-strictly. All non-usable rules are removed, and those dependency pairs and usable rules that have been oriented strictly or contain non-usable symbols in their left-hand side are removed as well.

The following dependency pairs can be deleted:

new_primQuotInt16(vvv46, Pos(Succ(vvv47400)), vvv506) → new_primQuotInt5(vvv46, Zero, vvv47400, vvv506, Zero)
new_primQuotInt14(vvv46, Succ(vvv475000), Zero, vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt14(vvv46, Zero, Succ(vvv309000), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt13(vvv46, Neg(Succ(vvv47500)), Neg(Succ(vvv30900)), vvv474) → new_primQuotInt14(vvv46, vvv47500, vvv30900, vvv474)
new_primQuotInt9(vvv1013, vvv1015) → new_primQuotInt8(vvv1013, new_rem(vvv1015))
new_primQuotInt13(vvv46, Neg(Succ(vvv47500)), Pos(vvv3090), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt24(vvv1020, vvv1022) → new_primQuotInt8(vvv1020, new_rem0(vvv1022))
new_primQuotInt16(vvv46, Neg(Succ(vvv47400)), vvv506) → new_primQuotInt17(vvv46, Zero, vvv47400, vvv506, Zero)
new_primQuotInt17(vvv1020, Zero, vvv1022, Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt8(vvv1020, new_rem0(vvv1022))
new_primQuotInt5(vvv1013, Zero, vvv1015, Pos(Succ(vvv101800)), vvv1036) → new_primQuotInt8(vvv1013, new_rem(vvv1015))
new_primQuotInt17(vvv1020, Zero, vvv1022, Neg(Succ(vvv102500)), vvv1038) → new_primQuotInt24(vvv1020, vvv1022)
new_primQuotInt13(vvv46, Neg(Zero), Neg(Succ(vvv30900)), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt13(vvv46, Neg(Succ(vvv47500)), Neg(Zero), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt12(vvv1013, vvv1054, vvv1058) → new_primQuotInt13(vvv1013, vvv1054, vvv1058, vvv1054)
new_primQuotInt14(vvv46, Succ(vvv475000), Succ(vvv309000), vvv474) → new_primQuotInt14(vvv46, vvv475000, vvv309000, vvv474)
new_primQuotInt13(vvv46, Pos(Succ(Succ(vvv475000))), Pos(Succ(Succ(vvv309000))), vvv474) → new_primQuotInt14(vvv46, vvv475000, vvv309000, vvv474)
new_primQuotInt13(vvv46, Pos(Succ(Succ(vvv475000))), Pos(Succ(Zero)), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt13(vvv46, Pos(Succ(Zero)), Pos(Succ(Succ(vvv309000))), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt13(vvv46, Pos(Succ(vvv47500)), Neg(vvv3090), vvv474) → new_primQuotInt16(vvv46, vvv474, new_fromInt)
new_primQuotInt13(vvv46, Neg(Zero), Pos(Succ(vvv30900)), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt13(vvv46, Pos(Zero), Neg(Succ(vvv30900)), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt5(vvv1013, Zero, vvv1015, Neg(Succ(vvv101800)), vvv1036) → new_primQuotInt9(vvv1013, vvv1015)
new_primQuotInt13(vvv46, Pos(Succ(vvv47500)), Pos(Zero), vvv474) → new_primQuotInt15(vvv46, vvv474)
new_primQuotInt13(vvv46, Pos(Zero), Pos(Succ(vvv30900)), vvv474) → new_primQuotInt15(vvv46, vvv474)
No rules are removed from R.

Used ordering: POLO with Polynomial interpretation [25]:

POL(Neg(x1)) = 2 + x1   
POL(Pos(x1)) = 2·x1   
POL(Succ(x1)) = 1 + 2·x1   
POL(Zero) = 0   
POL([]) = 0   
POL(error(x1)) = 2·x1   
POL(new_error) = 0   
POL(new_fromInt) = 0   
POL(new_primQuotInt12(x1, x2, x3)) = 1 + x1 + 2·x2 + 2·x3   
POL(new_primQuotInt13(x1, x2, x3, x4)) = x1 + x2 + 2·x3 + x4   
POL(new_primQuotInt14(x1, x2, x3, x4)) = x1 + 2·x2 + 2·x3 + x4   
POL(new_primQuotInt15(x1, x2)) = x1 + x2   
POL(new_primQuotInt16(x1, x2, x3)) = x1 + x2 + 2·x3   
POL(new_primQuotInt17(x1, x2, x3, x4, x5)) = 1 + x1 + 2·x2 + 2·x3 + x4 + x5   
POL(new_primQuotInt24(x1, x2)) = 2 + x1 + 2·x2   
POL(new_primQuotInt5(x1, x2, x3, x4, x5)) = x1 + 2·x2 + 2·x3 + x4 + x5   
POL(new_primQuotInt8(x1, x2)) = 1 + x1 + 2·x2   
POL(new_primQuotInt9(x1, x2)) = 2 + x1 + 2·x2   
POL(new_primRemInt3(x1)) = x1   
POL(new_primRemInt5(x1)) = x1   
POL(new_rem(x1)) = x1   
POL(new_rem0(x1)) = x1   



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ UsableRulesReductionPairsProof
QDP
                                              ↳ DependencyGraphProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt15(vvv46, vvv474) → new_primQuotInt16(vvv46, vvv474, new_fromInt)
new_primQuotInt8(vvv1013, vvv1054) → new_primQuotInt12(vvv1013, vvv1054, new_fromInt)

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_rem(vvv1160) → new_primRemInt5(vvv1160)
new_primRemInt5(vvv2200) → new_error
new_errorerror([])
new_rem0(vvv1008) → new_primRemInt3(vvv1008)
new_primRemInt3(vvv46800) → new_error

The set Q consists of the following terms:

new_rem0(x0)
new_rem(x0)
new_error
new_fromInt
new_primRemInt3(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 0 SCCs with 2 less nodes.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
QDP
                                  ↳ UsableRulesProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Zero, vvv1018, vvv1036) → new_primQuotInt5(vvv1013, new_primMinusNatS2(Succ(vvv103700), Zero), Zero, vvv1018, new_primMinusNatS2(Succ(vvv103700), Zero))

The TRS R consists of the following rules:

new_primRemInt3(vvv46800) → new_error
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_rem1(vvv1030) → new_primRemInt4(vvv1030)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_errorerror([])
new_rem(vvv1160) → new_primRemInt5(vvv1160)
new_rem0(vvv1008) → new_primRemInt3(vvv1008)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Zero) → Zero
new_rem2(vvv47200) → new_primRemInt6(vvv47200)
new_primRemInt6(vvv47200) → new_error
new_fromIntPos(Zero)
new_primRemInt5(vvv2200) → new_error
new_primRemInt4(vvv2200) → new_error

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
QDP
                                      ↳ QReductionProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Zero, vvv1018, vvv1036) → new_primQuotInt5(vvv1013, new_primMinusNatS2(Succ(vvv103700), Zero), Zero, vvv1018, new_primMinusNatS2(Succ(vvv103700), Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_error
new_fromInt
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
QDP
                                          ↳ RuleRemovalProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Zero, vvv1018, vvv1036) → new_primQuotInt5(vvv1013, new_primMinusNatS2(Succ(vvv103700), Zero), Zero, vvv1018, new_primMinusNatS2(Succ(vvv103700), Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the rule removal processor [15] with the following polynomial ordering [25], at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Zero, vvv1018, vvv1036) → new_primQuotInt5(vvv1013, new_primMinusNatS2(Succ(vvv103700), Zero), Zero, vvv1018, new_primMinusNatS2(Succ(vvv103700), Zero))


Used ordering: POLO with Polynomial interpretation [25]:

POL(Succ(x1)) = 1 + 2·x1   
POL(Zero) = 0   
POL(new_primMinusNatS2(x1, x2)) = x1 + 2·x2   
POL(new_primQuotInt5(x1, x2, x3, x4, x5)) = x1 + x2 + x3 + x4 + x5   



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ RuleRemovalProof
QDP
                                              ↳ PisEmptyProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
QDP
                                  ↳ UsableRulesProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Neg(vvv12240)) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), new_fromInt)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Zero)) → new_primQuotInt10(vvv1219, vvv1221, vvv1220)
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Succ(vvv101800)), vvv1036) → new_primQuotInt1(vvv1013, Zero, vvv101800, Succ(vvv10150), Zero)
new_primQuotInt4(vvv51, vvv2240, vvv520, vvv303) → new_primQuotInt5(vvv51, Succ(vvv2240), vvv520, vvv303, Succ(vvv2240))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Succ(vvv12230), vvv1224) → new_primQuotInt6(vvv1219, vvv1220, vvv1221, vvv12220, vvv12230, vvv1224)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Zero, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Zero, vvv1224) → new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224)
new_primQuotInt2(vvv1293, vvv1296, vvv1297, vvv1314) → new_primQuotInt4(vvv1293, vvv1296, vvv1297, vvv1314)
new_primQuotInt7(vvv1013, vvv10150) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, new_fromInt)
new_primQuotInt3(vvv1293, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, new_fromInt)
new_primQuotInt1(vvv1293, Succ(vvv12940), Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt1(vvv1293, vvv12940, vvv12950, vvv1296, vvv1297)
new_primQuotInt1(vvv1293, Succ(vvv12940), Zero, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, new_fromInt)
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Zero), vvv1036) → new_primQuotInt7(vvv1013, vvv10150)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Succ(vvv122400))) → new_primQuotInt1(vvv1219, Succ(vvv1220), vvv122400, vvv1221, Succ(vvv1220))
new_primQuotInt1(vvv1293, Zero, Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt3(vvv1293, vvv1296, vvv1297)
new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Succ(vvv10150), vvv1018, vvv1036) → new_primQuotInt6(vvv1013, vvv103700, Succ(vvv10150), vvv103700, vvv10150, vvv1018)
new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), new_fromInt)
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Neg(vvv10180), vvv1036) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, new_fromInt)
new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))

The TRS R consists of the following rules:

new_primRemInt3(vvv46800) → new_error
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_rem1(vvv1030) → new_primRemInt4(vvv1030)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_errorerror([])
new_rem(vvv1160) → new_primRemInt5(vvv1160)
new_rem0(vvv1008) → new_primRemInt3(vvv1008)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Zero) → Zero
new_rem2(vvv47200) → new_primRemInt6(vvv47200)
new_primRemInt6(vvv47200) → new_error
new_fromIntPos(Zero)
new_primRemInt5(vvv2200) → new_error
new_primRemInt4(vvv2200) → new_error

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
QDP
                                      ↳ QReductionProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Neg(vvv12240)) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), new_fromInt)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Zero)) → new_primQuotInt10(vvv1219, vvv1221, vvv1220)
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Succ(vvv101800)), vvv1036) → new_primQuotInt1(vvv1013, Zero, vvv101800, Succ(vvv10150), Zero)
new_primQuotInt4(vvv51, vvv2240, vvv520, vvv303) → new_primQuotInt5(vvv51, Succ(vvv2240), vvv520, vvv303, Succ(vvv2240))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Succ(vvv12230), vvv1224) → new_primQuotInt6(vvv1219, vvv1220, vvv1221, vvv12220, vvv12230, vvv1224)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Zero, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Zero, vvv1224) → new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224)
new_primQuotInt2(vvv1293, vvv1296, vvv1297, vvv1314) → new_primQuotInt4(vvv1293, vvv1296, vvv1297, vvv1314)
new_primQuotInt7(vvv1013, vvv10150) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, new_fromInt)
new_primQuotInt3(vvv1293, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, new_fromInt)
new_primQuotInt1(vvv1293, Succ(vvv12940), Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt1(vvv1293, vvv12940, vvv12950, vvv1296, vvv1297)
new_primQuotInt1(vvv1293, Succ(vvv12940), Zero, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, new_fromInt)
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Zero), vvv1036) → new_primQuotInt7(vvv1013, vvv10150)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Succ(vvv122400))) → new_primQuotInt1(vvv1219, Succ(vvv1220), vvv122400, vvv1221, Succ(vvv1220))
new_primQuotInt1(vvv1293, Zero, Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt3(vvv1293, vvv1296, vvv1297)
new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Succ(vvv10150), vvv1018, vvv1036) → new_primQuotInt6(vvv1013, vvv103700, Succ(vvv10150), vvv103700, vvv10150, vvv1018)
new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), new_fromInt)
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Neg(vvv10180), vvv1036) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, new_fromInt)
new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_error
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
QDP
                                          ↳ Rewriting
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Neg(vvv12240)) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), new_fromInt)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Zero)) → new_primQuotInt10(vvv1219, vvv1221, vvv1220)
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Succ(vvv101800)), vvv1036) → new_primQuotInt1(vvv1013, Zero, vvv101800, Succ(vvv10150), Zero)
new_primQuotInt4(vvv51, vvv2240, vvv520, vvv303) → new_primQuotInt5(vvv51, Succ(vvv2240), vvv520, vvv303, Succ(vvv2240))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Succ(vvv12230), vvv1224) → new_primQuotInt6(vvv1219, vvv1220, vvv1221, vvv12220, vvv12230, vvv1224)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Zero, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Zero, vvv1224) → new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224)
new_primQuotInt2(vvv1293, vvv1296, vvv1297, vvv1314) → new_primQuotInt4(vvv1293, vvv1296, vvv1297, vvv1314)
new_primQuotInt7(vvv1013, vvv10150) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, new_fromInt)
new_primQuotInt3(vvv1293, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, new_fromInt)
new_primQuotInt1(vvv1293, Succ(vvv12940), Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt1(vvv1293, vvv12940, vvv12950, vvv1296, vvv1297)
new_primQuotInt1(vvv1293, Succ(vvv12940), Zero, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, new_fromInt)
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Zero), vvv1036) → new_primQuotInt7(vvv1013, vvv10150)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Succ(vvv122400))) → new_primQuotInt1(vvv1219, Succ(vvv1220), vvv122400, vvv1221, Succ(vvv1220))
new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Succ(vvv10150), vvv1018, vvv1036) → new_primQuotInt6(vvv1013, vvv103700, Succ(vvv10150), vvv103700, vvv10150, vvv1018)
new_primQuotInt1(vvv1293, Zero, Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt3(vvv1293, vvv1296, vvv1297)
new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Neg(vvv10180), vvv1036) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, new_fromInt)
new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), new_fromInt)

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Neg(vvv12240)) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Neg(vvv12240)) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
QDP
                                              ↳ Rewriting
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Succ(vvv101800)), vvv1036) → new_primQuotInt1(vvv1013, Zero, vvv101800, Succ(vvv10150), Zero)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Zero)) → new_primQuotInt10(vvv1219, vvv1221, vvv1220)
new_primQuotInt4(vvv51, vvv2240, vvv520, vvv303) → new_primQuotInt5(vvv51, Succ(vvv2240), vvv520, vvv303, Succ(vvv2240))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Succ(vvv12230), vvv1224) → new_primQuotInt6(vvv1219, vvv1220, vvv1221, vvv12220, vvv12230, vvv1224)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Zero, vvv1224) → new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Zero, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt7(vvv1013, vvv10150) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, new_fromInt)
new_primQuotInt2(vvv1293, vvv1296, vvv1297, vvv1314) → new_primQuotInt4(vvv1293, vvv1296, vvv1297, vvv1314)
new_primQuotInt3(vvv1293, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, new_fromInt)
new_primQuotInt1(vvv1293, Succ(vvv12940), Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt1(vvv1293, vvv12940, vvv12950, vvv1296, vvv1297)
new_primQuotInt1(vvv1293, Succ(vvv12940), Zero, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, new_fromInt)
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Zero), vvv1036) → new_primQuotInt7(vvv1013, vvv10150)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Succ(vvv122400))) → new_primQuotInt1(vvv1219, Succ(vvv1220), vvv122400, vvv1221, Succ(vvv1220))
new_primQuotInt1(vvv1293, Zero, Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt3(vvv1293, vvv1296, vvv1297)
new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Succ(vvv10150), vvv1018, vvv1036) → new_primQuotInt6(vvv1013, vvv103700, Succ(vvv10150), vvv103700, vvv10150, vvv1018)
new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), new_fromInt)
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Neg(vvv10180), vvv1036) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, new_fromInt)
new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Neg(vvv12240)) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt7(vvv1013, vvv10150) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt7(vvv1013, vvv10150) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
QDP
                                                  ↳ Rewriting
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Zero)) → new_primQuotInt10(vvv1219, vvv1221, vvv1220)
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Succ(vvv101800)), vvv1036) → new_primQuotInt1(vvv1013, Zero, vvv101800, Succ(vvv10150), Zero)
new_primQuotInt4(vvv51, vvv2240, vvv520, vvv303) → new_primQuotInt5(vvv51, Succ(vvv2240), vvv520, vvv303, Succ(vvv2240))
new_primQuotInt7(vvv1013, vvv10150) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, Pos(Zero))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Succ(vvv12230), vvv1224) → new_primQuotInt6(vvv1219, vvv1220, vvv1221, vvv12220, vvv12230, vvv1224)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Zero, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Zero, vvv1224) → new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224)
new_primQuotInt2(vvv1293, vvv1296, vvv1297, vvv1314) → new_primQuotInt4(vvv1293, vvv1296, vvv1297, vvv1314)
new_primQuotInt3(vvv1293, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, new_fromInt)
new_primQuotInt1(vvv1293, Succ(vvv12940), Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt1(vvv1293, vvv12940, vvv12950, vvv1296, vvv1297)
new_primQuotInt1(vvv1293, Succ(vvv12940), Zero, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, new_fromInt)
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Zero), vvv1036) → new_primQuotInt7(vvv1013, vvv10150)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Succ(vvv122400))) → new_primQuotInt1(vvv1219, Succ(vvv1220), vvv122400, vvv1221, Succ(vvv1220))
new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Succ(vvv10150), vvv1018, vvv1036) → new_primQuotInt6(vvv1013, vvv103700, Succ(vvv10150), vvv103700, vvv10150, vvv1018)
new_primQuotInt1(vvv1293, Zero, Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt3(vvv1293, vvv1296, vvv1297)
new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Neg(vvv10180), vvv1036) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, new_fromInt)
new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), new_fromInt)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Neg(vvv12240)) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt3(vvv1293, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt3(vvv1293, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
QDP
                                                      ↳ Rewriting
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Succ(vvv101800)), vvv1036) → new_primQuotInt1(vvv1013, Zero, vvv101800, Succ(vvv10150), Zero)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Zero)) → new_primQuotInt10(vvv1219, vvv1221, vvv1220)
new_primQuotInt4(vvv51, vvv2240, vvv520, vvv303) → new_primQuotInt5(vvv51, Succ(vvv2240), vvv520, vvv303, Succ(vvv2240))
new_primQuotInt7(vvv1013, vvv10150) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, Pos(Zero))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Succ(vvv12230), vvv1224) → new_primQuotInt6(vvv1219, vvv1220, vvv1221, vvv12220, vvv12230, vvv1224)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Zero, vvv1224) → new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Zero, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt2(vvv1293, vvv1296, vvv1297, vvv1314) → new_primQuotInt4(vvv1293, vvv1296, vvv1297, vvv1314)
new_primQuotInt1(vvv1293, Succ(vvv12940), Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt1(vvv1293, vvv12940, vvv12950, vvv1296, vvv1297)
new_primQuotInt1(vvv1293, Succ(vvv12940), Zero, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, new_fromInt)
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Zero), vvv1036) → new_primQuotInt7(vvv1013, vvv10150)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Succ(vvv122400))) → new_primQuotInt1(vvv1219, Succ(vvv1220), vvv122400, vvv1221, Succ(vvv1220))
new_primQuotInt1(vvv1293, Zero, Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt3(vvv1293, vvv1296, vvv1297)
new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Succ(vvv10150), vvv1018, vvv1036) → new_primQuotInt6(vvv1013, vvv103700, Succ(vvv10150), vvv103700, vvv10150, vvv1018)
new_primQuotInt3(vvv1293, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, Pos(Zero))
new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), new_fromInt)
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Neg(vvv10180), vvv1036) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, new_fromInt)
new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Neg(vvv12240)) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt1(vvv1293, Succ(vvv12940), Zero, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt1(vvv1293, Succ(vvv12940), Zero, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
QDP
                                                          ↳ Rewriting
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Zero)) → new_primQuotInt10(vvv1219, vvv1221, vvv1220)
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Succ(vvv101800)), vvv1036) → new_primQuotInt1(vvv1013, Zero, vvv101800, Succ(vvv10150), Zero)
new_primQuotInt4(vvv51, vvv2240, vvv520, vvv303) → new_primQuotInt5(vvv51, Succ(vvv2240), vvv520, vvv303, Succ(vvv2240))
new_primQuotInt7(vvv1013, vvv10150) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, Pos(Zero))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Succ(vvv12230), vvv1224) → new_primQuotInt6(vvv1219, vvv1220, vvv1221, vvv12220, vvv12230, vvv1224)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Zero, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Zero, vvv1224) → new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224)
new_primQuotInt2(vvv1293, vvv1296, vvv1297, vvv1314) → new_primQuotInt4(vvv1293, vvv1296, vvv1297, vvv1314)
new_primQuotInt1(vvv1293, Succ(vvv12940), Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt1(vvv1293, vvv12940, vvv12950, vvv1296, vvv1297)
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Zero), vvv1036) → new_primQuotInt7(vvv1013, vvv10150)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Succ(vvv122400))) → new_primQuotInt1(vvv1219, Succ(vvv1220), vvv122400, vvv1221, Succ(vvv1220))
new_primQuotInt1(vvv1293, Succ(vvv12940), Zero, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, Pos(Zero))
new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Succ(vvv10150), vvv1018, vvv1036) → new_primQuotInt6(vvv1013, vvv103700, Succ(vvv10150), vvv103700, vvv10150, vvv1018)
new_primQuotInt1(vvv1293, Zero, Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt3(vvv1293, vvv1296, vvv1297)
new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Neg(vvv10180), vvv1036) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, new_fromInt)
new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), new_fromInt)
new_primQuotInt3(vvv1293, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, Pos(Zero))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Neg(vvv12240)) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
QDP
                                                              ↳ Rewriting
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Succ(vvv101800)), vvv1036) → new_primQuotInt1(vvv1013, Zero, vvv101800, Succ(vvv10150), Zero)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Zero)) → new_primQuotInt10(vvv1219, vvv1221, vvv1220)
new_primQuotInt4(vvv51, vvv2240, vvv520, vvv303) → new_primQuotInt5(vvv51, Succ(vvv2240), vvv520, vvv303, Succ(vvv2240))
new_primQuotInt7(vvv1013, vvv10150) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, Pos(Zero))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Succ(vvv12230), vvv1224) → new_primQuotInt6(vvv1219, vvv1220, vvv1221, vvv12220, vvv12230, vvv1224)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Zero, vvv1224) → new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Zero, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt2(vvv1293, vvv1296, vvv1297, vvv1314) → new_primQuotInt4(vvv1293, vvv1296, vvv1297, vvv1314)
new_primQuotInt1(vvv1293, Succ(vvv12940), Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt1(vvv1293, vvv12940, vvv12950, vvv1296, vvv1297)
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Zero), vvv1036) → new_primQuotInt7(vvv1013, vvv10150)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Succ(vvv122400))) → new_primQuotInt1(vvv1219, Succ(vvv1220), vvv122400, vvv1221, Succ(vvv1220))
new_primQuotInt1(vvv1293, Zero, Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt3(vvv1293, vvv1296, vvv1297)
new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Succ(vvv10150), vvv1018, vvv1036) → new_primQuotInt6(vvv1013, vvv103700, Succ(vvv10150), vvv103700, vvv10150, vvv1018)
new_primQuotInt1(vvv1293, Succ(vvv12940), Zero, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, Pos(Zero))
new_primQuotInt3(vvv1293, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, Pos(Zero))
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Neg(vvv10180), vvv1036) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, new_fromInt)
new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Neg(vvv12240)) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Neg(vvv10180), vvv1036) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Neg(vvv10180), vvv1036) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
QDP
                                                                  ↳ UsableRulesProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Zero)) → new_primQuotInt10(vvv1219, vvv1221, vvv1220)
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Succ(vvv101800)), vvv1036) → new_primQuotInt1(vvv1013, Zero, vvv101800, Succ(vvv10150), Zero)
new_primQuotInt4(vvv51, vvv2240, vvv520, vvv303) → new_primQuotInt5(vvv51, Succ(vvv2240), vvv520, vvv303, Succ(vvv2240))
new_primQuotInt7(vvv1013, vvv10150) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, Pos(Zero))
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Neg(vvv10180), vvv1036) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, Pos(Zero))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Succ(vvv12230), vvv1224) → new_primQuotInt6(vvv1219, vvv1220, vvv1221, vvv12220, vvv12230, vvv1224)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Zero, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Zero, vvv1224) → new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224)
new_primQuotInt2(vvv1293, vvv1296, vvv1297, vvv1314) → new_primQuotInt4(vvv1293, vvv1296, vvv1297, vvv1314)
new_primQuotInt1(vvv1293, Succ(vvv12940), Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt1(vvv1293, vvv12940, vvv12950, vvv1296, vvv1297)
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Zero), vvv1036) → new_primQuotInt7(vvv1013, vvv10150)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Succ(vvv122400))) → new_primQuotInt1(vvv1219, Succ(vvv1220), vvv122400, vvv1221, Succ(vvv1220))
new_primQuotInt1(vvv1293, Succ(vvv12940), Zero, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, Pos(Zero))
new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Succ(vvv10150), vvv1018, vvv1036) → new_primQuotInt6(vvv1013, vvv103700, Succ(vvv10150), vvv103700, vvv10150, vvv1018)
new_primQuotInt1(vvv1293, Zero, Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt3(vvv1293, vvv1296, vvv1297)
new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt3(vvv1293, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, Pos(Zero))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Neg(vvv12240)) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))
new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
QDP
                                                                      ↳ QReductionProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Zero)) → new_primQuotInt10(vvv1219, vvv1221, vvv1220)
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Succ(vvv101800)), vvv1036) → new_primQuotInt1(vvv1013, Zero, vvv101800, Succ(vvv10150), Zero)
new_primQuotInt4(vvv51, vvv2240, vvv520, vvv303) → new_primQuotInt5(vvv51, Succ(vvv2240), vvv520, vvv303, Succ(vvv2240))
new_primQuotInt7(vvv1013, vvv10150) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, Pos(Zero))
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Neg(vvv10180), vvv1036) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, Pos(Zero))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Succ(vvv12230), vvv1224) → new_primQuotInt6(vvv1219, vvv1220, vvv1221, vvv12220, vvv12230, vvv1224)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Zero, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Zero, vvv1224) → new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224)
new_primQuotInt2(vvv1293, vvv1296, vvv1297, vvv1314) → new_primQuotInt4(vvv1293, vvv1296, vvv1297, vvv1314)
new_primQuotInt1(vvv1293, Succ(vvv12940), Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt1(vvv1293, vvv12940, vvv12950, vvv1296, vvv1297)
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Zero), vvv1036) → new_primQuotInt7(vvv1013, vvv10150)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Succ(vvv122400))) → new_primQuotInt1(vvv1219, Succ(vvv1220), vvv122400, vvv1221, Succ(vvv1220))
new_primQuotInt1(vvv1293, Succ(vvv12940), Zero, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, Pos(Zero))
new_primQuotInt1(vvv1293, Zero, Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt3(vvv1293, vvv1296, vvv1297)
new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Succ(vvv10150), vvv1018, vvv1036) → new_primQuotInt6(vvv1013, vvv103700, Succ(vvv10150), vvv103700, vvv10150, vvv1018)
new_primQuotInt3(vvv1293, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, Pos(Zero))
new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Neg(vvv12240)) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_fromInt



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
QDP
                                                                          ↳ Instantiation
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Zero)) → new_primQuotInt10(vvv1219, vvv1221, vvv1220)
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Succ(vvv101800)), vvv1036) → new_primQuotInt1(vvv1013, Zero, vvv101800, Succ(vvv10150), Zero)
new_primQuotInt4(vvv51, vvv2240, vvv520, vvv303) → new_primQuotInt5(vvv51, Succ(vvv2240), vvv520, vvv303, Succ(vvv2240))
new_primQuotInt7(vvv1013, vvv10150) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, Pos(Zero))
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Neg(vvv10180), vvv1036) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, Pos(Zero))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Succ(vvv12230), vvv1224) → new_primQuotInt6(vvv1219, vvv1220, vvv1221, vvv12220, vvv12230, vvv1224)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Zero, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Zero, vvv1224) → new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224)
new_primQuotInt2(vvv1293, vvv1296, vvv1297, vvv1314) → new_primQuotInt4(vvv1293, vvv1296, vvv1297, vvv1314)
new_primQuotInt1(vvv1293, Succ(vvv12940), Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt1(vvv1293, vvv12940, vvv12950, vvv1296, vvv1297)
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Zero), vvv1036) → new_primQuotInt7(vvv1013, vvv10150)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Succ(vvv122400))) → new_primQuotInt1(vvv1219, Succ(vvv1220), vvv122400, vvv1221, Succ(vvv1220))
new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Succ(vvv10150), vvv1018, vvv1036) → new_primQuotInt6(vvv1013, vvv103700, Succ(vvv10150), vvv103700, vvv10150, vvv1018)
new_primQuotInt1(vvv1293, Zero, Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt3(vvv1293, vvv1296, vvv1297)
new_primQuotInt1(vvv1293, Succ(vvv12940), Zero, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, Pos(Zero))
new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt3(vvv1293, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, Pos(Zero))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Neg(vvv12240)) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))
new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt2(vvv1293, vvv1296, vvv1297, vvv1314) → new_primQuotInt4(vvv1293, vvv1296, vvv1297, vvv1314) we obtained the following new rules:

new_primQuotInt2(z0, z2, z3, Pos(Zero)) → new_primQuotInt4(z0, z2, z3, Pos(Zero))
new_primQuotInt2(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt4(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt2(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
QDP
                                                                              ↳ Instantiation
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Succ(vvv101800)), vvv1036) → new_primQuotInt1(vvv1013, Zero, vvv101800, Succ(vvv10150), Zero)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Zero)) → new_primQuotInt10(vvv1219, vvv1221, vvv1220)
new_primQuotInt4(vvv51, vvv2240, vvv520, vvv303) → new_primQuotInt5(vvv51, Succ(vvv2240), vvv520, vvv303, Succ(vvv2240))
new_primQuotInt2(z0, z2, z3, Pos(Zero)) → new_primQuotInt4(z0, z2, z3, Pos(Zero))
new_primQuotInt7(vvv1013, vvv10150) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, Pos(Zero))
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Neg(vvv10180), vvv1036) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, Pos(Zero))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Succ(vvv12230), vvv1224) → new_primQuotInt6(vvv1219, vvv1220, vvv1221, vvv12220, vvv12230, vvv1224)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Zero, vvv1224) → new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Zero, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt2(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt1(vvv1293, Succ(vvv12940), Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt1(vvv1293, vvv12940, vvv12950, vvv1296, vvv1297)
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Zero), vvv1036) → new_primQuotInt7(vvv1013, vvv10150)
new_primQuotInt2(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt4(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Succ(vvv122400))) → new_primQuotInt1(vvv1219, Succ(vvv1220), vvv122400, vvv1221, Succ(vvv1220))
new_primQuotInt1(vvv1293, Succ(vvv12940), Zero, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, Pos(Zero))
new_primQuotInt1(vvv1293, Zero, Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt3(vvv1293, vvv1296, vvv1297)
new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Succ(vvv10150), vvv1018, vvv1036) → new_primQuotInt6(vvv1013, vvv103700, Succ(vvv10150), vvv103700, vvv10150, vvv1018)
new_primQuotInt3(vvv1293, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, Pos(Zero))
new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Neg(vvv12240)) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt4(vvv51, vvv2240, vvv520, vvv303) → new_primQuotInt5(vvv51, Succ(vvv2240), vvv520, vvv303, Succ(vvv2240)) we obtained the following new rules:

new_primQuotInt4(z0, z1, z2, Pos(Zero)) → new_primQuotInt5(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt4(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt5(z0, Succ(Succ(z1)), Zero, Pos(Zero), Succ(Succ(z1)))
new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt5(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
QDP
                                                                                  ↳ DependencyGraphProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Zero)) → new_primQuotInt10(vvv1219, vvv1221, vvv1220)
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Succ(vvv101800)), vvv1036) → new_primQuotInt1(vvv1013, Zero, vvv101800, Succ(vvv10150), Zero)
new_primQuotInt2(z0, z2, z3, Pos(Zero)) → new_primQuotInt4(z0, z2, z3, Pos(Zero))
new_primQuotInt7(vvv1013, vvv10150) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, Pos(Zero))
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Neg(vvv10180), vvv1036) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, Pos(Zero))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Succ(vvv12230), vvv1224) → new_primQuotInt6(vvv1219, vvv1220, vvv1221, vvv12220, vvv12230, vvv1224)
new_primQuotInt4(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt5(z0, Succ(Succ(z1)), Zero, Pos(Zero), Succ(Succ(z1)))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Zero, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Zero, vvv1224) → new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224)
new_primQuotInt2(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt1(vvv1293, Succ(vvv12940), Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt1(vvv1293, vvv12940, vvv12950, vvv1296, vvv1297)
new_primQuotInt4(z0, z1, z2, Pos(Zero)) → new_primQuotInt5(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Zero), vvv1036) → new_primQuotInt7(vvv1013, vvv10150)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Succ(vvv122400))) → new_primQuotInt1(vvv1219, Succ(vvv1220), vvv122400, vvv1221, Succ(vvv1220))
new_primQuotInt2(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt4(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Succ(vvv10150), vvv1018, vvv1036) → new_primQuotInt6(vvv1013, vvv103700, Succ(vvv10150), vvv103700, vvv10150, vvv1018)
new_primQuotInt1(vvv1293, Zero, Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt3(vvv1293, vvv1296, vvv1297)
new_primQuotInt1(vvv1293, Succ(vvv12940), Zero, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, Pos(Zero))
new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt5(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt3(vvv1293, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, Pos(Zero))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Neg(vvv12240)) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))
new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
QDP
                                                                                      ↳ QDPOrderProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Zero)) → new_primQuotInt10(vvv1219, vvv1221, vvv1220)
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Succ(vvv101800)), vvv1036) → new_primQuotInt1(vvv1013, Zero, vvv101800, Succ(vvv10150), Zero)
new_primQuotInt2(z0, z2, z3, Pos(Zero)) → new_primQuotInt4(z0, z2, z3, Pos(Zero))
new_primQuotInt7(vvv1013, vvv10150) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, Pos(Zero))
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Neg(vvv10180), vvv1036) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, Pos(Zero))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Succ(vvv12230), vvv1224) → new_primQuotInt6(vvv1219, vvv1220, vvv1221, vvv12220, vvv12230, vvv1224)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Zero, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Zero, vvv1224) → new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224)
new_primQuotInt2(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt1(vvv1293, Succ(vvv12940), Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt1(vvv1293, vvv12940, vvv12950, vvv1296, vvv1297)
new_primQuotInt4(z0, z1, z2, Pos(Zero)) → new_primQuotInt5(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Zero), vvv1036) → new_primQuotInt7(vvv1013, vvv10150)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Succ(vvv122400))) → new_primQuotInt1(vvv1219, Succ(vvv1220), vvv122400, vvv1221, Succ(vvv1220))
new_primQuotInt2(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt4(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt1(vvv1293, Succ(vvv12940), Zero, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, Pos(Zero))
new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Succ(vvv10150), vvv1018, vvv1036) → new_primQuotInt6(vvv1013, vvv103700, Succ(vvv10150), vvv103700, vvv10150, vvv1018)
new_primQuotInt1(vvv1293, Zero, Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt3(vvv1293, vvv1296, vvv1297)
new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt5(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt3(vvv1293, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, Pos(Zero))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Neg(vvv12240)) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))
new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Neg(vvv10180), vvv1036) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, Pos(Zero))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Neg(vvv12240)) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))
The remaining pairs can at least be oriented weakly.

new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Zero)) → new_primQuotInt10(vvv1219, vvv1221, vvv1220)
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Succ(vvv101800)), vvv1036) → new_primQuotInt1(vvv1013, Zero, vvv101800, Succ(vvv10150), Zero)
new_primQuotInt2(z0, z2, z3, Pos(Zero)) → new_primQuotInt4(z0, z2, z3, Pos(Zero))
new_primQuotInt7(vvv1013, vvv10150) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, Pos(Zero))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Succ(vvv12230), vvv1224) → new_primQuotInt6(vvv1219, vvv1220, vvv1221, vvv12220, vvv12230, vvv1224)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Zero, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Zero, vvv1224) → new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224)
new_primQuotInt2(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt1(vvv1293, Succ(vvv12940), Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt1(vvv1293, vvv12940, vvv12950, vvv1296, vvv1297)
new_primQuotInt4(z0, z1, z2, Pos(Zero)) → new_primQuotInt5(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Zero), vvv1036) → new_primQuotInt7(vvv1013, vvv10150)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Succ(vvv122400))) → new_primQuotInt1(vvv1219, Succ(vvv1220), vvv122400, vvv1221, Succ(vvv1220))
new_primQuotInt2(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt4(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt1(vvv1293, Succ(vvv12940), Zero, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, Pos(Zero))
new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Succ(vvv10150), vvv1018, vvv1036) → new_primQuotInt6(vvv1013, vvv103700, Succ(vvv10150), vvv103700, vvv10150, vvv1018)
new_primQuotInt1(vvv1293, Zero, Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt3(vvv1293, vvv1296, vvv1297)
new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt5(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt3(vvv1293, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, Pos(Zero))
new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))
Used ordering: Polynomial interpretation [25]:

POL(Neg(x1)) = 1   
POL(Pos(x1)) = 0   
POL(Succ(x1)) = 0   
POL(Zero) = 0   
POL(new_primMinusNatS2(x1, x2)) = 1   
POL(new_primQuotInt1(x1, x2, x3, x4, x5)) = 0   
POL(new_primQuotInt10(x1, x2, x3)) = 0   
POL(new_primQuotInt11(x1, x2, x3, x4)) = x4   
POL(new_primQuotInt2(x1, x2, x3, x4)) = 0   
POL(new_primQuotInt3(x1, x2, x3)) = 0   
POL(new_primQuotInt4(x1, x2, x3, x4)) = 0   
POL(new_primQuotInt5(x1, x2, x3, x4, x5)) = x4   
POL(new_primQuotInt6(x1, x2, x3, x4, x5, x6)) = x6   
POL(new_primQuotInt7(x1, x2)) = 0   

The following usable rules [17] were oriented: none



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
QDP
                                                                                          ↳ QDPOrderProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Zero)) → new_primQuotInt10(vvv1219, vvv1221, vvv1220)
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Succ(vvv101800)), vvv1036) → new_primQuotInt1(vvv1013, Zero, vvv101800, Succ(vvv10150), Zero)
new_primQuotInt2(z0, z2, z3, Pos(Zero)) → new_primQuotInt4(z0, z2, z3, Pos(Zero))
new_primQuotInt7(vvv1013, vvv10150) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, Pos(Zero))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Succ(vvv12230), vvv1224) → new_primQuotInt6(vvv1219, vvv1220, vvv1221, vvv12220, vvv12230, vvv1224)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Zero, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Zero, vvv1224) → new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224)
new_primQuotInt2(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt1(vvv1293, Succ(vvv12940), Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt1(vvv1293, vvv12940, vvv12950, vvv1296, vvv1297)
new_primQuotInt4(z0, z1, z2, Pos(Zero)) → new_primQuotInt5(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Zero), vvv1036) → new_primQuotInt7(vvv1013, vvv10150)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Succ(vvv122400))) → new_primQuotInt1(vvv1219, Succ(vvv1220), vvv122400, vvv1221, Succ(vvv1220))
new_primQuotInt2(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt4(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt1(vvv1293, Zero, Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt3(vvv1293, vvv1296, vvv1297)
new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Succ(vvv10150), vvv1018, vvv1036) → new_primQuotInt6(vvv1013, vvv103700, Succ(vvv10150), vvv103700, vvv10150, vvv1018)
new_primQuotInt1(vvv1293, Succ(vvv12940), Zero, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, Pos(Zero))
new_primQuotInt3(vvv1293, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, Pos(Zero))
new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt5(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Succ(vvv101800)), vvv1036) → new_primQuotInt1(vvv1013, Zero, vvv101800, Succ(vvv10150), Zero)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Succ(vvv122400))) → new_primQuotInt1(vvv1219, Succ(vvv1220), vvv122400, vvv1221, Succ(vvv1220))
The remaining pairs can at least be oriented weakly.

new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Zero)) → new_primQuotInt10(vvv1219, vvv1221, vvv1220)
new_primQuotInt2(z0, z2, z3, Pos(Zero)) → new_primQuotInt4(z0, z2, z3, Pos(Zero))
new_primQuotInt7(vvv1013, vvv10150) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, Pos(Zero))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Succ(vvv12230), vvv1224) → new_primQuotInt6(vvv1219, vvv1220, vvv1221, vvv12220, vvv12230, vvv1224)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Zero, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Zero, vvv1224) → new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224)
new_primQuotInt2(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt1(vvv1293, Succ(vvv12940), Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt1(vvv1293, vvv12940, vvv12950, vvv1296, vvv1297)
new_primQuotInt4(z0, z1, z2, Pos(Zero)) → new_primQuotInt5(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Zero), vvv1036) → new_primQuotInt7(vvv1013, vvv10150)
new_primQuotInt2(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt4(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt1(vvv1293, Zero, Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt3(vvv1293, vvv1296, vvv1297)
new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Succ(vvv10150), vvv1018, vvv1036) → new_primQuotInt6(vvv1013, vvv103700, Succ(vvv10150), vvv103700, vvv10150, vvv1018)
new_primQuotInt1(vvv1293, Succ(vvv12940), Zero, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, Pos(Zero))
new_primQuotInt3(vvv1293, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, Pos(Zero))
new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt5(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))
Used ordering: Polynomial interpretation [25]:

POL(Pos(x1)) = x1   
POL(Succ(x1)) = 1   
POL(Zero) = 0   
POL(new_primMinusNatS2(x1, x2)) = 0   
POL(new_primQuotInt1(x1, x2, x3, x4, x5)) = 0   
POL(new_primQuotInt10(x1, x2, x3)) = 0   
POL(new_primQuotInt11(x1, x2, x3, x4)) = x4   
POL(new_primQuotInt2(x1, x2, x3, x4)) = 0   
POL(new_primQuotInt3(x1, x2, x3)) = 0   
POL(new_primQuotInt4(x1, x2, x3, x4)) = 0   
POL(new_primQuotInt5(x1, x2, x3, x4, x5)) = x4   
POL(new_primQuotInt6(x1, x2, x3, x4, x5, x6)) = x6   
POL(new_primQuotInt7(x1, x2)) = 0   

The following usable rules [17] were oriented: none



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ QDPOrderProof
QDP
                                                                                              ↳ DependencyGraphProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Zero)) → new_primQuotInt10(vvv1219, vvv1221, vvv1220)
new_primQuotInt2(z0, z2, z3, Pos(Zero)) → new_primQuotInt4(z0, z2, z3, Pos(Zero))
new_primQuotInt7(vvv1013, vvv10150) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, Pos(Zero))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Succ(vvv12230), vvv1224) → new_primQuotInt6(vvv1219, vvv1220, vvv1221, vvv12220, vvv12230, vvv1224)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Zero, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Zero, vvv1224) → new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224)
new_primQuotInt2(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt1(vvv1293, Succ(vvv12940), Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt1(vvv1293, vvv12940, vvv12950, vvv1296, vvv1297)
new_primQuotInt4(z0, z1, z2, Pos(Zero)) → new_primQuotInt5(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Zero), vvv1036) → new_primQuotInt7(vvv1013, vvv10150)
new_primQuotInt2(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt4(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt1(vvv1293, Succ(vvv12940), Zero, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, Pos(Zero))
new_primQuotInt1(vvv1293, Zero, Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt3(vvv1293, vvv1296, vvv1297)
new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Succ(vvv10150), vvv1018, vvv1036) → new_primQuotInt6(vvv1013, vvv103700, Succ(vvv10150), vvv103700, vvv10150, vvv1018)
new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt5(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt3(vvv1293, vvv1296, vvv1297) → new_primQuotInt2(vvv1293, vvv1296, vvv1297, Pos(Zero))
new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 2 SCCs with 3 less nodes.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ QDPOrderProof
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ AND
QDP
                                                                                                    ↳ Instantiation
                                                                                                  ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Zero)) → new_primQuotInt10(vvv1219, vvv1221, vvv1220)
new_primQuotInt2(z0, z2, z3, Pos(Zero)) → new_primQuotInt4(z0, z2, z3, Pos(Zero))
new_primQuotInt7(vvv1013, vvv10150) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, Pos(Zero))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Succ(vvv12230), vvv1224) → new_primQuotInt6(vvv1219, vvv1220, vvv1221, vvv12220, vvv12230, vvv1224)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Zero, vvv1224) → new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Zero, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt2(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt4(z0, z1, z2, Pos(Zero)) → new_primQuotInt5(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Zero), vvv1036) → new_primQuotInt7(vvv1013, vvv10150)
new_primQuotInt2(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt4(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Succ(vvv10150), vvv1018, vvv1036) → new_primQuotInt6(vvv1013, vvv103700, Succ(vvv10150), vvv103700, vvv10150, vvv1018)
new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt5(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt2(z0, z2, z3, Pos(Zero)) → new_primQuotInt4(z0, z2, z3, Pos(Zero)) we obtained the following new rules:

new_primQuotInt2(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt4(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt2(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ QDPOrderProof
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ AND
                                                                                                  ↳ QDP
                                                                                                    ↳ Instantiation
QDP
                                                                                                        ↳ Instantiation
                                                                                                  ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Zero)) → new_primQuotInt10(vvv1219, vvv1221, vvv1220)
new_primQuotInt7(vvv1013, vvv10150) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, Pos(Zero))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Succ(vvv12230), vvv1224) → new_primQuotInt6(vvv1219, vvv1220, vvv1221, vvv12220, vvv12230, vvv1224)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Zero, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Zero, vvv1224) → new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224)
new_primQuotInt2(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt4(z0, z1, z2, Pos(Zero)) → new_primQuotInt5(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Zero), vvv1036) → new_primQuotInt7(vvv1013, vvv10150)
new_primQuotInt2(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt4(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Succ(vvv10150), vvv1018, vvv1036) → new_primQuotInt6(vvv1013, vvv103700, Succ(vvv10150), vvv103700, vvv10150, vvv1018)
new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt5(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt4(z0, z1, z2, Pos(Zero)) → new_primQuotInt5(z0, Succ(z1), z2, Pos(Zero), Succ(z1)) we obtained the following new rules:

new_primQuotInt4(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt5(z0, Succ(Succ(z1)), Zero, Pos(Zero), Succ(Succ(z1)))
new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt5(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ QDPOrderProof
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ AND
                                                                                                  ↳ QDP
                                                                                                    ↳ Instantiation
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
QDP
                                                                                                            ↳ DependencyGraphProof
                                                                                                  ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Zero)) → new_primQuotInt10(vvv1219, vvv1221, vvv1220)
new_primQuotInt7(vvv1013, vvv10150) → new_primQuotInt2(vvv1013, Succ(vvv10150), Zero, Pos(Zero))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Succ(vvv12230), vvv1224) → new_primQuotInt6(vvv1219, vvv1220, vvv1221, vvv12220, vvv12230, vvv1224)
new_primQuotInt4(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt5(z0, Succ(Succ(z1)), Zero, Pos(Zero), Succ(Succ(z1)))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Zero, vvv1224) → new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Zero, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt2(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt5(vvv1013, Succ(Zero), Succ(vvv10150), Pos(Zero), vvv1036) → new_primQuotInt7(vvv1013, vvv10150)
new_primQuotInt2(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt4(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Succ(vvv10150), vvv1018, vvv1036) → new_primQuotInt6(vvv1013, vvv103700, Succ(vvv10150), vvv103700, vvv10150, vvv1018)
new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt5(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 4 less nodes.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ QDPOrderProof
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ AND
                                                                                                  ↳ QDP
                                                                                                    ↳ Instantiation
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ DependencyGraphProof
QDP
                                                                                                                ↳ QDPOrderProof
                                                                                                  ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Zero)) → new_primQuotInt10(vvv1219, vvv1221, vvv1220)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Succ(vvv12230), vvv1224) → new_primQuotInt6(vvv1219, vvv1220, vvv1221, vvv12220, vvv12230, vvv1224)
new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Succ(vvv10150), vvv1018, vvv1036) → new_primQuotInt6(vvv1013, vvv103700, Succ(vvv10150), vvv103700, vvv10150, vvv1018)
new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt5(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Zero, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Zero, vvv1224) → new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224)
new_primQuotInt2(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Zero, vvv1224) → new_primQuotInt5(vvv1219, new_primMinusNatS2(Succ(vvv1220), vvv1221), vvv1221, vvv1224, new_primMinusNatS2(Succ(vvv1220), vvv1221))
The remaining pairs can at least be oriented weakly.

new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Zero)) → new_primQuotInt10(vvv1219, vvv1221, vvv1220)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Succ(vvv12230), vvv1224) → new_primQuotInt6(vvv1219, vvv1220, vvv1221, vvv12220, vvv12230, vvv1224)
new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Succ(vvv10150), vvv1018, vvv1036) → new_primQuotInt6(vvv1013, vvv103700, Succ(vvv10150), vvv103700, vvv10150, vvv1018)
new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt5(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Zero, vvv1224) → new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224)
new_primQuotInt2(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))
Used ordering: Matrix interpretation [3]:
Non-tuple symbols:
M( Succ(x1) ) =
/1\
\0/
+
/00\
\11/
·x1

M( new_primMinusNatS2(x1, x2) ) =
/0\
\0/
+
/00\
\01/
·x1+
/11\
\00/
·x2

M( Zero ) =
/1\
\0/

M( Pos(x1) ) =
/0\
\0/
+
/10\
\00/
·x1

Tuple symbols:
M( new_primQuotInt5(x1, ..., x5) ) = 0+
[0,1]
·x1+
[0,1]
·x2+
[1,1]
·x3+
[0,0]
·x4+
[0,0]
·x5

M( new_primQuotInt6(x1, ..., x6) ) = 1+
[0,1]
·x1+
[1,1]
·x2+
[1,1]
·x3+
[0,0]
·x4+
[0,0]
·x5+
[0,0]
·x6

M( new_primQuotInt2(x1, ..., x4) ) = 0+
[0,1]
·x1+
[1,1]
·x2+
[0,1]
·x3+
[1,0]
·x4

M( new_primQuotInt10(x1, ..., x3) ) = 1+
[0,1]
·x1+
[1,1]
·x2+
[1,1]
·x3

M( new_primQuotInt4(x1, ..., x4) ) = 0+
[0,1]
·x1+
[1,1]
·x2+
[0,1]
·x3+
[1,0]
·x4

M( new_primQuotInt11(x1, ..., x4) ) = 1+
[0,1]
·x1+
[1,1]
·x2+
[1,1]
·x3+
[0,0]
·x4


Matrix type:
We used a basic matrix type which is not further parametrizeable.


As matrix orders are CE-compatible, we used usable rules w.r.t. argument filtering in the order.
The following usable rules [17] were oriented:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ QDPOrderProof
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ AND
                                                                                                  ↳ QDP
                                                                                                    ↳ Instantiation
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ DependencyGraphProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QDPOrderProof
QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                  ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Zero)) → new_primQuotInt10(vvv1219, vvv1221, vvv1220)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Succ(vvv12230), vvv1224) → new_primQuotInt6(vvv1219, vvv1220, vvv1221, vvv12220, vvv12230, vvv1224)
new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Succ(vvv10150), vvv1018, vvv1036) → new_primQuotInt6(vvv1013, vvv103700, Succ(vvv10150), vvv103700, vvv10150, vvv1018)
new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt5(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Zero, vvv1224) → new_primQuotInt11(vvv1219, vvv1220, vvv1221, vvv1224)
new_primQuotInt2(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ QDPOrderProof
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ AND
                                                                                                  ↳ QDP
                                                                                                    ↳ Instantiation
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ DependencyGraphProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QDPOrderProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
QDP
                                                                                                                        ↳ UsableRulesProof
                                                                                                  ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Zero)) → new_primQuotInt10(vvv1219, vvv1221, vvv1220)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Succ(vvv12230), vvv1224) → new_primQuotInt6(vvv1219, vvv1220, vvv1221, vvv12220, vvv12230, vvv1224)
new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Succ(vvv10150), vvv1018, vvv1036) → new_primQuotInt6(vvv1013, vvv103700, Succ(vvv10150), vvv103700, vvv10150, vvv1018)
new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt5(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt2(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ QDPOrderProof
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ AND
                                                                                                  ↳ QDP
                                                                                                    ↳ Instantiation
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ DependencyGraphProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QDPOrderProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ UsableRulesProof
QDP
                                                                                                                            ↳ QReductionProof
                                                                                                  ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Zero)) → new_primQuotInt10(vvv1219, vvv1221, vvv1220)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Succ(vvv12230), vvv1224) → new_primQuotInt6(vvv1219, vvv1220, vvv1221, vvv12220, vvv12230, vvv1224)
new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Succ(vvv10150), vvv1018, vvv1036) → new_primQuotInt6(vvv1013, vvv103700, Succ(vvv10150), vvv103700, vvv10150, vvv1018)
new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt5(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt2(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))

R is empty.
The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ QDPOrderProof
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ AND
                                                                                                  ↳ QDP
                                                                                                    ↳ Instantiation
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ DependencyGraphProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QDPOrderProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ UsableRulesProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ QReductionProof
QDP
                                                                                                                                ↳ Instantiation
                                                                                                  ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Zero)) → new_primQuotInt10(vvv1219, vvv1221, vvv1220)
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Succ(vvv12230), vvv1224) → new_primQuotInt6(vvv1219, vvv1220, vvv1221, vvv12220, vvv12230, vvv1224)
new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Succ(vvv10150), vvv1018, vvv1036) → new_primQuotInt6(vvv1013, vvv103700, Succ(vvv10150), vvv103700, vvv10150, vvv1018)
new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt5(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt2(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt5(vvv1013, Succ(Succ(vvv103700)), Succ(vvv10150), vvv1018, vvv1036) → new_primQuotInt6(vvv1013, vvv103700, Succ(vvv10150), vvv103700, vvv10150, vvv1018) we obtained the following new rules:

new_primQuotInt5(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt6(z0, x1, Succ(z2), x1, z2, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ QDPOrderProof
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ AND
                                                                                                  ↳ QDP
                                                                                                    ↳ Instantiation
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ DependencyGraphProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QDPOrderProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ UsableRulesProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ QReductionProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
QDP
                                                                                                                                    ↳ NonInfProof
                                                                                                  ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Zero)) → new_primQuotInt10(vvv1219, vvv1221, vvv1220)
new_primQuotInt5(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt6(z0, x1, Succ(z2), x1, z2, Pos(Zero))
new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Succ(vvv12230), vvv1224) → new_primQuotInt6(vvv1219, vvv1220, vvv1221, vvv12220, vvv12230, vvv1224)
new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt5(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt2(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The DP Problem is simplified using the Induction Calculus [18] with the following steps:
Note that final constraints are written in bold face.


For Pair new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Zero)) → new_primQuotInt10(vvv1219, vvv1221, vvv1220) the following chains were created:




For Pair new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Succ(vvv12230), vvv1224) → new_primQuotInt6(vvv1219, vvv1220, vvv1221, vvv12220, vvv12230, vvv1224) the following chains were created:




For Pair new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt5(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1)) the following chains were created:




For Pair new_primQuotInt2(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero)) the following chains were created:




For Pair new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero)) the following chains were created:




For Pair new_primQuotInt5(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt6(z0, x1, Succ(z2), x1, z2, Pos(Zero)) the following chains were created:




To summarize, we get the following constraints P for the following pairs.



The constraints for P> respective Pbound are constructed from P where we just replace every occurence of "t ≥ s" in P by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for Pbound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation [18]:

POL(Pos(x1)) = 0   
POL(Succ(x1)) = 1 + x1   
POL(Zero) = 0   
POL(c) = -1   
POL(new_primQuotInt10(x1, x2, x3)) = x1 + x3   
POL(new_primQuotInt2(x1, x2, x3, x4)) = -1 + x1 + x3 - x4   
POL(new_primQuotInt4(x1, x2, x3, x4)) = -1 + x1 + x3 - x4   
POL(new_primQuotInt5(x1, x2, x3, x4, x5)) = -1 + x1 + x2 + x3 - x4 - x5   
POL(new_primQuotInt6(x1, x2, x3, x4, x5, x6)) = x1 + x2 - x4 + x5 - x6   

The following pairs are in P>:

new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Zero)) → new_primQuotInt10(vvv1219, vvv1221, vvv1220)
The following pairs are in Pbound:

new_primQuotInt6(vvv1219, vvv1220, vvv1221, Zero, Succ(vvv12230), Pos(Zero)) → new_primQuotInt10(vvv1219, vvv1221, vvv1220)
new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt5(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt2(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))
new_primQuotInt5(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt6(z0, x1, Succ(z2), x1, z2, Pos(Zero))
There are no usable rules

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ QDPOrderProof
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ AND
                                                                                                  ↳ QDP
                                                                                                    ↳ Instantiation
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ DependencyGraphProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QDPOrderProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ UsableRulesProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ QReductionProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ NonInfProof
QDP
                                                                                                                                        ↳ DependencyGraphProof
                                                                                                  ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Succ(vvv12230), vvv1224) → new_primQuotInt6(vvv1219, vvv1220, vvv1221, vvv12220, vvv12230, vvv1224)
new_primQuotInt5(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt6(z0, x1, Succ(z2), x1, z2, Pos(Zero))
new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt5(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt2(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt4(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt10(vvv1219, vvv1221, vvv1220) → new_primQuotInt2(vvv1219, vvv1221, Succ(vvv1220), Pos(Zero))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 4 less nodes.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ QDPOrderProof
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ AND
                                                                                                  ↳ QDP
                                                                                                    ↳ Instantiation
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ DependencyGraphProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QDPOrderProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ UsableRulesProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ QReductionProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ NonInfProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ DependencyGraphProof
QDP
                                                                                                                                            ↳ QDPSizeChangeProof
                                                                                                  ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt6(vvv1219, vvv1220, vvv1221, Succ(vvv12220), Succ(vvv12230), vvv1224) → new_primQuotInt6(vvv1219, vvv1220, vvv1221, vvv12220, vvv12230, vvv1224)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ QDPOrderProof
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ AND
                                                                                                  ↳ QDP
QDP
                                                                                                    ↳ UsableRulesProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt1(vvv1293, Succ(vvv12940), Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt1(vvv1293, vvv12940, vvv12950, vvv1296, vvv1297)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ QDPOrderProof
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ AND
                                                                                                  ↳ QDP
                                                                                                  ↳ QDP
                                                                                                    ↳ UsableRulesProof
QDP
                                                                                                        ↳ QReductionProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt1(vvv1293, Succ(vvv12940), Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt1(vvv1293, vvv12940, vvv12950, vvv1296, vvv1297)

R is empty.
The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ QDPOrderProof
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ AND
                                                                                                  ↳ QDP
                                                                                                  ↳ QDP
                                                                                                    ↳ UsableRulesProof
                                                                                                      ↳ QDP
                                                                                                        ↳ QReductionProof
QDP
                                                                                                            ↳ QDPSizeChangeProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt1(vvv1293, Succ(vvv12940), Succ(vvv12950), vvv1296, vvv1297) → new_primQuotInt1(vvv1293, vvv12940, vvv12950, vvv1296, vvv1297)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
QDP
                                  ↳ UsableRulesProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt44(vvv51, Neg(Succ(vvv47200)), vvv504) → new_primQuotInt45(vvv51, Zero, vvv47200, vvv504, Zero)
new_primQuotInt18(vvv51, Neg(Zero), Neg(Succ(vvv29500)), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt18(vvv51, Neg(Succ(vvv47300)), Neg(Zero), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt42(vvv51, Succ(vvv473000), Zero, vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt42(vvv51, Zero, Succ(vvv295000), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt30(vvv1028, Zero, vvv1030, Pos(Succ(vvv103300)), vvv1047) → new_primQuotInt35(vvv1028, new_rem1(vvv1030))
new_primQuotInt45(vvv1068, Zero, vvv1070, Pos(Succ(vvv107300)), vvv1083) → new_primQuotInt35(vvv1068, new_rem2(vvv1070))
new_primQuotInt30(vvv1028, Zero, vvv1030, Neg(Succ(vvv103300)), vvv1047) → new_primQuotInt36(vvv1028, vvv1030)
new_primQuotInt18(vvv51, Pos(Zero), Neg(Succ(vvv29500)), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt18(vvv51, Neg(Zero), Pos(Succ(vvv29500)), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt18(vvv51, Pos(Succ(Succ(vvv473000))), Pos(Succ(Succ(vvv295000))), vvv472) → new_primQuotInt42(vvv51, vvv473000, vvv295000, vvv472)
new_primQuotInt35(vvv1068, vvv1094) → new_primQuotInt41(vvv1068, vvv1094, new_fromInt)
new_primQuotInt18(vvv51, Pos(Zero), Pos(Succ(vvv29500)), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt18(vvv51, Pos(Succ(vvv47300)), Pos(Zero), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt43(vvv51, vvv472) → new_primQuotInt44(vvv51, vvv472, new_fromInt)
new_primQuotInt18(vvv51, Pos(Succ(vvv47300)), Neg(vvv2950), vvv472) → new_primQuotInt44(vvv51, vvv472, new_fromInt)
new_primQuotInt45(vvv1068, Zero, vvv1070, Neg(Succ(vvv107300)), vvv1083) → new_primQuotInt51(vvv1068, vvv1070)
new_primQuotInt44(vvv51, Pos(Succ(vvv47200)), vvv504) → new_primQuotInt30(vvv51, Zero, vvv47200, vvv504, Zero)
new_primQuotInt18(vvv51, Pos(Succ(Zero)), Pos(Succ(Succ(vvv295000))), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt18(vvv51, Pos(Succ(Succ(vvv473000))), Pos(Succ(Zero)), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt42(vvv51, Succ(vvv473000), Succ(vvv295000), vvv472) → new_primQuotInt42(vvv51, vvv473000, vvv295000, vvv472)
new_primQuotInt41(vvv1068, vvv1094, vvv1097) → new_primQuotInt18(vvv1068, vvv1094, vvv1097, vvv1094)
new_primQuotInt36(vvv1028, vvv1030) → new_primQuotInt35(vvv1028, new_rem1(vvv1030))
new_primQuotInt51(vvv1068, vvv1070) → new_primQuotInt35(vvv1068, new_rem2(vvv1070))
new_primQuotInt18(vvv51, Neg(Succ(vvv47300)), Neg(Succ(vvv29500)), vvv472) → new_primQuotInt42(vvv51, vvv47300, vvv29500, vvv472)
new_primQuotInt18(vvv51, Neg(Succ(vvv47300)), Pos(vvv2950), vvv472) → new_primQuotInt43(vvv51, vvv472)

The TRS R consists of the following rules:

new_primRemInt3(vvv46800) → new_error
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_rem1(vvv1030) → new_primRemInt4(vvv1030)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_errorerror([])
new_rem(vvv1160) → new_primRemInt5(vvv1160)
new_rem0(vvv1008) → new_primRemInt3(vvv1008)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Zero) → Zero
new_rem2(vvv47200) → new_primRemInt6(vvv47200)
new_primRemInt6(vvv47200) → new_error
new_fromIntPos(Zero)
new_primRemInt5(vvv2200) → new_error
new_primRemInt4(vvv2200) → new_error

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
QDP
                                      ↳ QReductionProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt44(vvv51, Neg(Succ(vvv47200)), vvv504) → new_primQuotInt45(vvv51, Zero, vvv47200, vvv504, Zero)
new_primQuotInt18(vvv51, Neg(Zero), Neg(Succ(vvv29500)), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt18(vvv51, Neg(Succ(vvv47300)), Neg(Zero), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt42(vvv51, Succ(vvv473000), Zero, vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt42(vvv51, Zero, Succ(vvv295000), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt30(vvv1028, Zero, vvv1030, Pos(Succ(vvv103300)), vvv1047) → new_primQuotInt35(vvv1028, new_rem1(vvv1030))
new_primQuotInt45(vvv1068, Zero, vvv1070, Pos(Succ(vvv107300)), vvv1083) → new_primQuotInt35(vvv1068, new_rem2(vvv1070))
new_primQuotInt30(vvv1028, Zero, vvv1030, Neg(Succ(vvv103300)), vvv1047) → new_primQuotInt36(vvv1028, vvv1030)
new_primQuotInt18(vvv51, Pos(Zero), Neg(Succ(vvv29500)), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt18(vvv51, Neg(Zero), Pos(Succ(vvv29500)), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt18(vvv51, Pos(Succ(Succ(vvv473000))), Pos(Succ(Succ(vvv295000))), vvv472) → new_primQuotInt42(vvv51, vvv473000, vvv295000, vvv472)
new_primQuotInt35(vvv1068, vvv1094) → new_primQuotInt41(vvv1068, vvv1094, new_fromInt)
new_primQuotInt18(vvv51, Pos(Zero), Pos(Succ(vvv29500)), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt18(vvv51, Pos(Succ(vvv47300)), Pos(Zero), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt43(vvv51, vvv472) → new_primQuotInt44(vvv51, vvv472, new_fromInt)
new_primQuotInt18(vvv51, Pos(Succ(vvv47300)), Neg(vvv2950), vvv472) → new_primQuotInt44(vvv51, vvv472, new_fromInt)
new_primQuotInt45(vvv1068, Zero, vvv1070, Neg(Succ(vvv107300)), vvv1083) → new_primQuotInt51(vvv1068, vvv1070)
new_primQuotInt44(vvv51, Pos(Succ(vvv47200)), vvv504) → new_primQuotInt30(vvv51, Zero, vvv47200, vvv504, Zero)
new_primQuotInt18(vvv51, Pos(Succ(Zero)), Pos(Succ(Succ(vvv295000))), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt18(vvv51, Pos(Succ(Succ(vvv473000))), Pos(Succ(Zero)), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt42(vvv51, Succ(vvv473000), Succ(vvv295000), vvv472) → new_primQuotInt42(vvv51, vvv473000, vvv295000, vvv472)
new_primQuotInt41(vvv1068, vvv1094, vvv1097) → new_primQuotInt18(vvv1068, vvv1094, vvv1097, vvv1094)
new_primQuotInt36(vvv1028, vvv1030) → new_primQuotInt35(vvv1028, new_rem1(vvv1030))
new_primQuotInt51(vvv1068, vvv1070) → new_primQuotInt35(vvv1068, new_rem2(vvv1070))
new_primQuotInt18(vvv51, Neg(Succ(vvv47300)), Neg(Succ(vvv29500)), vvv472) → new_primQuotInt42(vvv51, vvv47300, vvv29500, vvv472)
new_primQuotInt18(vvv51, Neg(Succ(vvv47300)), Pos(vvv2950), vvv472) → new_primQuotInt43(vvv51, vvv472)

The TRS R consists of the following rules:

new_rem1(vvv1030) → new_primRemInt4(vvv1030)
new_primRemInt4(vvv2200) → new_error
new_errorerror([])
new_fromIntPos(Zero)
new_rem2(vvv47200) → new_primRemInt6(vvv47200)
new_primRemInt6(vvv47200) → new_error

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt5(x0)



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
QDP
                                          ↳ UsableRulesReductionPairsProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt44(vvv51, Neg(Succ(vvv47200)), vvv504) → new_primQuotInt45(vvv51, Zero, vvv47200, vvv504, Zero)
new_primQuotInt18(vvv51, Neg(Succ(vvv47300)), Neg(Zero), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt18(vvv51, Neg(Zero), Neg(Succ(vvv29500)), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt42(vvv51, Zero, Succ(vvv295000), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt42(vvv51, Succ(vvv473000), Zero, vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt30(vvv1028, Zero, vvv1030, Pos(Succ(vvv103300)), vvv1047) → new_primQuotInt35(vvv1028, new_rem1(vvv1030))
new_primQuotInt45(vvv1068, Zero, vvv1070, Pos(Succ(vvv107300)), vvv1083) → new_primQuotInt35(vvv1068, new_rem2(vvv1070))
new_primQuotInt30(vvv1028, Zero, vvv1030, Neg(Succ(vvv103300)), vvv1047) → new_primQuotInt36(vvv1028, vvv1030)
new_primQuotInt18(vvv51, Neg(Zero), Pos(Succ(vvv29500)), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt18(vvv51, Pos(Zero), Neg(Succ(vvv29500)), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt18(vvv51, Pos(Zero), Pos(Succ(vvv29500)), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt35(vvv1068, vvv1094) → new_primQuotInt41(vvv1068, vvv1094, new_fromInt)
new_primQuotInt18(vvv51, Pos(Succ(Succ(vvv473000))), Pos(Succ(Succ(vvv295000))), vvv472) → new_primQuotInt42(vvv51, vvv473000, vvv295000, vvv472)
new_primQuotInt18(vvv51, Pos(Succ(vvv47300)), Pos(Zero), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt43(vvv51, vvv472) → new_primQuotInt44(vvv51, vvv472, new_fromInt)
new_primQuotInt18(vvv51, Pos(Succ(vvv47300)), Neg(vvv2950), vvv472) → new_primQuotInt44(vvv51, vvv472, new_fromInt)
new_primQuotInt45(vvv1068, Zero, vvv1070, Neg(Succ(vvv107300)), vvv1083) → new_primQuotInt51(vvv1068, vvv1070)
new_primQuotInt44(vvv51, Pos(Succ(vvv47200)), vvv504) → new_primQuotInt30(vvv51, Zero, vvv47200, vvv504, Zero)
new_primQuotInt18(vvv51, Pos(Succ(Zero)), Pos(Succ(Succ(vvv295000))), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt18(vvv51, Pos(Succ(Succ(vvv473000))), Pos(Succ(Zero)), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt42(vvv51, Succ(vvv473000), Succ(vvv295000), vvv472) → new_primQuotInt42(vvv51, vvv473000, vvv295000, vvv472)
new_primQuotInt41(vvv1068, vvv1094, vvv1097) → new_primQuotInt18(vvv1068, vvv1094, vvv1097, vvv1094)
new_primQuotInt36(vvv1028, vvv1030) → new_primQuotInt35(vvv1028, new_rem1(vvv1030))
new_primQuotInt51(vvv1068, vvv1070) → new_primQuotInt35(vvv1068, new_rem2(vvv1070))
new_primQuotInt18(vvv51, Neg(Succ(vvv47300)), Pos(vvv2950), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt18(vvv51, Neg(Succ(vvv47300)), Neg(Succ(vvv29500)), vvv472) → new_primQuotInt42(vvv51, vvv47300, vvv29500, vvv472)

The TRS R consists of the following rules:

new_rem1(vvv1030) → new_primRemInt4(vvv1030)
new_primRemInt4(vvv2200) → new_error
new_errorerror([])
new_fromIntPos(Zero)
new_rem2(vvv47200) → new_primRemInt6(vvv47200)
new_primRemInt6(vvv47200) → new_error

The set Q consists of the following terms:

new_rem2(x0)
new_rem1(x0)
new_primRemInt6(x0)
new_error
new_fromInt
new_primRemInt4(x0)

We have to consider all minimal (P,Q,R)-chains.
By using the usable rules with reduction pair processor [15] with a polynomial ordering [25], all dependency pairs and the corresponding usable rules [17] can be oriented non-strictly. All non-usable rules are removed, and those dependency pairs and usable rules that have been oriented strictly or contain non-usable symbols in their left-hand side are removed as well.

The following dependency pairs can be deleted:

new_primQuotInt44(vvv51, Neg(Succ(vvv47200)), vvv504) → new_primQuotInt45(vvv51, Zero, vvv47200, vvv504, Zero)
new_primQuotInt18(vvv51, Neg(Succ(vvv47300)), Neg(Zero), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt18(vvv51, Neg(Zero), Neg(Succ(vvv29500)), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt42(vvv51, Zero, Succ(vvv295000), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt42(vvv51, Succ(vvv473000), Zero, vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt30(vvv1028, Zero, vvv1030, Pos(Succ(vvv103300)), vvv1047) → new_primQuotInt35(vvv1028, new_rem1(vvv1030))
new_primQuotInt45(vvv1068, Zero, vvv1070, Pos(Succ(vvv107300)), vvv1083) → new_primQuotInt35(vvv1068, new_rem2(vvv1070))
new_primQuotInt30(vvv1028, Zero, vvv1030, Neg(Succ(vvv103300)), vvv1047) → new_primQuotInt36(vvv1028, vvv1030)
new_primQuotInt18(vvv51, Neg(Zero), Pos(Succ(vvv29500)), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt18(vvv51, Pos(Zero), Neg(Succ(vvv29500)), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt18(vvv51, Pos(Zero), Pos(Succ(vvv29500)), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt18(vvv51, Pos(Succ(Succ(vvv473000))), Pos(Succ(Succ(vvv295000))), vvv472) → new_primQuotInt42(vvv51, vvv473000, vvv295000, vvv472)
new_primQuotInt18(vvv51, Pos(Succ(vvv47300)), Pos(Zero), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt18(vvv51, Pos(Succ(vvv47300)), Neg(vvv2950), vvv472) → new_primQuotInt44(vvv51, vvv472, new_fromInt)
new_primQuotInt45(vvv1068, Zero, vvv1070, Neg(Succ(vvv107300)), vvv1083) → new_primQuotInt51(vvv1068, vvv1070)
new_primQuotInt44(vvv51, Pos(Succ(vvv47200)), vvv504) → new_primQuotInt30(vvv51, Zero, vvv47200, vvv504, Zero)
new_primQuotInt18(vvv51, Pos(Succ(Zero)), Pos(Succ(Succ(vvv295000))), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt18(vvv51, Pos(Succ(Succ(vvv473000))), Pos(Succ(Zero)), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt42(vvv51, Succ(vvv473000), Succ(vvv295000), vvv472) → new_primQuotInt42(vvv51, vvv473000, vvv295000, vvv472)
new_primQuotInt18(vvv51, Neg(Succ(vvv47300)), Pos(vvv2950), vvv472) → new_primQuotInt43(vvv51, vvv472)
new_primQuotInt18(vvv51, Neg(Succ(vvv47300)), Neg(Succ(vvv29500)), vvv472) → new_primQuotInt42(vvv51, vvv47300, vvv29500, vvv472)
No rules are removed from R.

Used ordering: POLO with Polynomial interpretation [25]:

POL(Neg(x1)) = 2·x1   
POL(Pos(x1)) = 2·x1   
POL(Succ(x1)) = 2·x1   
POL(Zero) = 0   
POL([]) = 0   
POL(error(x1)) = x1   
POL(new_error) = 0   
POL(new_fromInt) = 0   
POL(new_primQuotInt18(x1, x2, x3, x4)) = x1 + x2 + 2·x3 + x4   
POL(new_primQuotInt30(x1, x2, x3, x4, x5)) = x1 + 2·x2 + 2·x3 + x4 + 2·x5   
POL(new_primQuotInt35(x1, x2)) = x1 + 2·x2   
POL(new_primQuotInt36(x1, x2)) = x1 + 2·x2   
POL(new_primQuotInt41(x1, x2, x3)) = x1 + 2·x2 + 2·x3   
POL(new_primQuotInt42(x1, x2, x3, x4)) = x1 + 2·x2 + x3 + x4   
POL(new_primQuotInt43(x1, x2)) = x1 + x2   
POL(new_primQuotInt44(x1, x2, x3)) = x1 + x2 + x3   
POL(new_primQuotInt45(x1, x2, x3, x4, x5)) = x1 + x2 + 2·x3 + x4 + 2·x5   
POL(new_primQuotInt51(x1, x2)) = x1 + 2·x2   
POL(new_primRemInt4(x1)) = x1   
POL(new_primRemInt6(x1)) = x1   
POL(new_rem1(x1)) = x1   
POL(new_rem2(x1)) = x1   



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ UsableRulesReductionPairsProof
QDP
                                              ↳ DependencyGraphProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt51(vvv1068, vvv1070) → new_primQuotInt35(vvv1068, new_rem2(vvv1070))
new_primQuotInt35(vvv1068, vvv1094) → new_primQuotInt41(vvv1068, vvv1094, new_fromInt)
new_primQuotInt43(vvv51, vvv472) → new_primQuotInt44(vvv51, vvv472, new_fromInt)
new_primQuotInt41(vvv1068, vvv1094, vvv1097) → new_primQuotInt18(vvv1068, vvv1094, vvv1097, vvv1094)
new_primQuotInt36(vvv1028, vvv1030) → new_primQuotInt35(vvv1028, new_rem1(vvv1030))

The TRS R consists of the following rules:

new_rem1(vvv1030) → new_primRemInt4(vvv1030)
new_primRemInt4(vvv2200) → new_error
new_errorerror([])
new_fromIntPos(Zero)
new_rem2(vvv47200) → new_primRemInt6(vvv47200)
new_primRemInt6(vvv47200) → new_error

The set Q consists of the following terms:

new_rem2(x0)
new_rem1(x0)
new_primRemInt6(x0)
new_error
new_fromInt
new_primRemInt4(x0)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 0 SCCs with 5 less nodes.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
QDP
                                  ↳ UsableRulesProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Zero, vvv1033, vvv1047) → new_primQuotInt30(vvv1028, new_primMinusNatS2(Succ(vvv104800), Zero), Zero, vvv1033, new_primMinusNatS2(Succ(vvv104800), Zero))

The TRS R consists of the following rules:

new_primRemInt3(vvv46800) → new_error
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_rem1(vvv1030) → new_primRemInt4(vvv1030)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_errorerror([])
new_rem(vvv1160) → new_primRemInt5(vvv1160)
new_rem0(vvv1008) → new_primRemInt3(vvv1008)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Zero) → Zero
new_rem2(vvv47200) → new_primRemInt6(vvv47200)
new_primRemInt6(vvv47200) → new_error
new_fromIntPos(Zero)
new_primRemInt5(vvv2200) → new_error
new_primRemInt4(vvv2200) → new_error

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
QDP
                                      ↳ QReductionProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Zero, vvv1033, vvv1047) → new_primQuotInt30(vvv1028, new_primMinusNatS2(Succ(vvv104800), Zero), Zero, vvv1033, new_primMinusNatS2(Succ(vvv104800), Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_error
new_fromInt
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
QDP
                                          ↳ RuleRemovalProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Zero, vvv1033, vvv1047) → new_primQuotInt30(vvv1028, new_primMinusNatS2(Succ(vvv104800), Zero), Zero, vvv1033, new_primMinusNatS2(Succ(vvv104800), Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the rule removal processor [15] with the following polynomial ordering [25], at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Zero, vvv1033, vvv1047) → new_primQuotInt30(vvv1028, new_primMinusNatS2(Succ(vvv104800), Zero), Zero, vvv1033, new_primMinusNatS2(Succ(vvv104800), Zero))


Used ordering: POLO with Polynomial interpretation [25]:

POL(Succ(x1)) = 1 + 2·x1   
POL(Zero) = 0   
POL(new_primMinusNatS2(x1, x2)) = x1 + 2·x2   
POL(new_primQuotInt30(x1, x2, x3, x4, x5)) = x1 + x2 + x3 + x4 + x5   



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ RuleRemovalProof
QDP
                                              ↳ PisEmptyProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
QDP
                                  ↳ UsableRulesProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt45(vvv1068, Succ(Succ(vvv108400)), Zero, vvv1073, vvv1083) → new_primQuotInt45(vvv1068, new_primMinusNatS2(Succ(vvv108400), Zero), Zero, vvv1073, new_primMinusNatS2(Succ(vvv108400), Zero))

The TRS R consists of the following rules:

new_primRemInt3(vvv46800) → new_error
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_rem1(vvv1030) → new_primRemInt4(vvv1030)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_errorerror([])
new_rem(vvv1160) → new_primRemInt5(vvv1160)
new_rem0(vvv1008) → new_primRemInt3(vvv1008)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Zero) → Zero
new_rem2(vvv47200) → new_primRemInt6(vvv47200)
new_primRemInt6(vvv47200) → new_error
new_fromIntPos(Zero)
new_primRemInt5(vvv2200) → new_error
new_primRemInt4(vvv2200) → new_error

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
QDP
                                      ↳ QReductionProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt45(vvv1068, Succ(Succ(vvv108400)), Zero, vvv1073, vvv1083) → new_primQuotInt45(vvv1068, new_primMinusNatS2(Succ(vvv108400), Zero), Zero, vvv1073, new_primMinusNatS2(Succ(vvv108400), Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_error
new_fromInt
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
QDP
                                          ↳ RuleRemovalProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt45(vvv1068, Succ(Succ(vvv108400)), Zero, vvv1073, vvv1083) → new_primQuotInt45(vvv1068, new_primMinusNatS2(Succ(vvv108400), Zero), Zero, vvv1073, new_primMinusNatS2(Succ(vvv108400), Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the rule removal processor [15] with the following polynomial ordering [25], at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

new_primQuotInt45(vvv1068, Succ(Succ(vvv108400)), Zero, vvv1073, vvv1083) → new_primQuotInt45(vvv1068, new_primMinusNatS2(Succ(vvv108400), Zero), Zero, vvv1073, new_primMinusNatS2(Succ(vvv108400), Zero))


Used ordering: POLO with Polynomial interpretation [25]:

POL(Succ(x1)) = 1 + 2·x1   
POL(Zero) = 0   
POL(new_primMinusNatS2(x1, x2)) = x1 + 2·x2   
POL(new_primQuotInt45(x1, x2, x3, x4, x5)) = x1 + x2 + x3 + x4 + x5   



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ RuleRemovalProof
QDP
                                              ↳ PisEmptyProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
QDP
                                  ↳ UsableRulesProof
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Zero, vvv1025, vvv1038) → new_primQuotInt17(vvv1020, new_primMinusNatS2(Succ(vvv103900), Zero), Zero, vvv1025, new_primMinusNatS2(Succ(vvv103900), Zero))

The TRS R consists of the following rules:

new_primRemInt3(vvv46800) → new_error
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_rem1(vvv1030) → new_primRemInt4(vvv1030)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_errorerror([])
new_rem(vvv1160) → new_primRemInt5(vvv1160)
new_rem0(vvv1008) → new_primRemInt3(vvv1008)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Zero) → Zero
new_rem2(vvv47200) → new_primRemInt6(vvv47200)
new_primRemInt6(vvv47200) → new_error
new_fromIntPos(Zero)
new_primRemInt5(vvv2200) → new_error
new_primRemInt4(vvv2200) → new_error

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
QDP
                                      ↳ QReductionProof
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Zero, vvv1025, vvv1038) → new_primQuotInt17(vvv1020, new_primMinusNatS2(Succ(vvv103900), Zero), Zero, vvv1025, new_primMinusNatS2(Succ(vvv103900), Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_error
new_fromInt
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
QDP
                                          ↳ RuleRemovalProof
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Zero, vvv1025, vvv1038) → new_primQuotInt17(vvv1020, new_primMinusNatS2(Succ(vvv103900), Zero), Zero, vvv1025, new_primMinusNatS2(Succ(vvv103900), Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the rule removal processor [15] with the following polynomial ordering [25], at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Zero, vvv1025, vvv1038) → new_primQuotInt17(vvv1020, new_primMinusNatS2(Succ(vvv103900), Zero), Zero, vvv1025, new_primMinusNatS2(Succ(vvv103900), Zero))


Used ordering: POLO with Polynomial interpretation [25]:

POL(Succ(x1)) = 1 + 2·x1   
POL(Zero) = 0   
POL(new_primMinusNatS2(x1, x2)) = x1 + 2·x2   
POL(new_primQuotInt17(x1, x2, x3, x4, x5)) = x1 + x2 + x3 + x4 + x5   



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ RuleRemovalProof
QDP
                                              ↳ PisEmptyProof
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
QDP
                                  ↳ UsableRulesProof
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Zero), vvv1047) → new_primQuotInt34(vvv1028, vvv10300)
new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, new_fromInt)
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt26(vvv1300, vvv1303, vvv1304, vvv1319) → new_primQuotInt29(vvv1300, vvv1303, vvv1304, vvv1319)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Succ(vvv119100))) → new_primQuotInt33(vvv1186, Succ(vvv1187), vvv119100, vvv1188, Succ(vvv1187))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Succ(vvv103300)), vvv1047) → new_primQuotInt33(vvv1028, Zero, vvv103300, Succ(vvv10300), Zero)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt37(vvv1186, vvv1188, vvv1187) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), new_fromInt)
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), new_fromInt)
new_primQuotInt32(vvv1265, vvv1268, vvv1269, vvv1291) → new_primQuotInt39(vvv1265, vvv1268, vvv1269, vvv1291)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt33(vvv1265, Succ(vvv12660), Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt33(vvv1265, vvv12660, vvv12670, vvv1268, vvv1269)
new_primQuotInt40(vvv1265, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, new_fromInt)
new_primQuotInt34(vvv1028, vvv10300) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, new_fromInt)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Zero)) → new_primQuotInt37(vvv1186, vvv1188, vvv1187)
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, new_fromInt)
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt33(vvv1265, Zero, Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt40(vvv1265, vvv1268, vvv1269)
new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, new_fromInt)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Pos(vvv10330), vvv1047) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, new_fromInt)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Neg(vvv10250), vvv1038) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt29(vvv699, vvv700, vvv703, vvv704) → new_primQuotInt30(vvv699, Succ(vvv700), vvv703, vvv704, Succ(vvv700))
new_primQuotInt33(vvv1265, Succ(vvv12660), Zero, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, new_fromInt)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt21(vvv1020, Zero, vvv102500, Succ(vvv10220), Zero)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)
new_primQuotInt21(vvv1300, Zero, Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt28(vvv1300, vvv1303, vvv1304)
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), new_fromInt)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Neg(vvv12310)) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), new_fromInt)
new_primQuotInt39(vvv436, vvv4410, vvv437, vvv479) → new_primQuotInt17(vvv436, Succ(vvv4410), vvv437, vvv479, Succ(vvv4410))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Succ(vvv123100))) → new_primQuotInt21(vvv1226, Succ(vvv1227), vvv123100, vvv1228, Succ(vvv1227))

The TRS R consists of the following rules:

new_primRemInt3(vvv46800) → new_error
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_rem1(vvv1030) → new_primRemInt4(vvv1030)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_errorerror([])
new_rem(vvv1160) → new_primRemInt5(vvv1160)
new_rem0(vvv1008) → new_primRemInt3(vvv1008)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Zero) → Zero
new_rem2(vvv47200) → new_primRemInt6(vvv47200)
new_primRemInt6(vvv47200) → new_error
new_fromIntPos(Zero)
new_primRemInt5(vvv2200) → new_error
new_primRemInt4(vvv2200) → new_error

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
QDP
                                      ↳ QReductionProof
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Zero), vvv1047) → new_primQuotInt34(vvv1028, vvv10300)
new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, new_fromInt)
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt26(vvv1300, vvv1303, vvv1304, vvv1319) → new_primQuotInt29(vvv1300, vvv1303, vvv1304, vvv1319)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Succ(vvv119100))) → new_primQuotInt33(vvv1186, Succ(vvv1187), vvv119100, vvv1188, Succ(vvv1187))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Succ(vvv103300)), vvv1047) → new_primQuotInt33(vvv1028, Zero, vvv103300, Succ(vvv10300), Zero)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt37(vvv1186, vvv1188, vvv1187) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), new_fromInt)
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), new_fromInt)
new_primQuotInt32(vvv1265, vvv1268, vvv1269, vvv1291) → new_primQuotInt39(vvv1265, vvv1268, vvv1269, vvv1291)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt33(vvv1265, Succ(vvv12660), Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt33(vvv1265, vvv12660, vvv12670, vvv1268, vvv1269)
new_primQuotInt40(vvv1265, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, new_fromInt)
new_primQuotInt34(vvv1028, vvv10300) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, new_fromInt)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Zero)) → new_primQuotInt37(vvv1186, vvv1188, vvv1187)
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, new_fromInt)
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt33(vvv1265, Zero, Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt40(vvv1265, vvv1268, vvv1269)
new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, new_fromInt)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Pos(vvv10330), vvv1047) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, new_fromInt)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Neg(vvv10250), vvv1038) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt29(vvv699, vvv700, vvv703, vvv704) → new_primQuotInt30(vvv699, Succ(vvv700), vvv703, vvv704, Succ(vvv700))
new_primQuotInt33(vvv1265, Succ(vvv12660), Zero, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, new_fromInt)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt21(vvv1020, Zero, vvv102500, Succ(vvv10220), Zero)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)
new_primQuotInt21(vvv1300, Zero, Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt28(vvv1300, vvv1303, vvv1304)
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), new_fromInt)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Neg(vvv12310)) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), new_fromInt)
new_primQuotInt39(vvv436, vvv4410, vvv437, vvv479) → new_primQuotInt17(vvv436, Succ(vvv4410), vvv437, vvv479, Succ(vvv4410))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Succ(vvv123100))) → new_primQuotInt21(vvv1226, Succ(vvv1227), vvv123100, vvv1228, Succ(vvv1227))

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_error
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
QDP
                                          ↳ Rewriting
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Zero), vvv1047) → new_primQuotInt34(vvv1028, vvv10300)
new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, new_fromInt)
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Succ(vvv119100))) → new_primQuotInt33(vvv1186, Succ(vvv1187), vvv119100, vvv1188, Succ(vvv1187))
new_primQuotInt26(vvv1300, vvv1303, vvv1304, vvv1319) → new_primQuotInt29(vvv1300, vvv1303, vvv1304, vvv1319)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Succ(vvv103300)), vvv1047) → new_primQuotInt33(vvv1028, Zero, vvv103300, Succ(vvv10300), Zero)
new_primQuotInt37(vvv1186, vvv1188, vvv1187) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), new_fromInt)
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), new_fromInt)
new_primQuotInt32(vvv1265, vvv1268, vvv1269, vvv1291) → new_primQuotInt39(vvv1265, vvv1268, vvv1269, vvv1291)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt33(vvv1265, Succ(vvv12660), Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt33(vvv1265, vvv12660, vvv12670, vvv1268, vvv1269)
new_primQuotInt40(vvv1265, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, new_fromInt)
new_primQuotInt34(vvv1028, vvv10300) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, new_fromInt)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Zero)) → new_primQuotInt37(vvv1186, vvv1188, vvv1187)
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, new_fromInt)
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt33(vvv1265, Zero, Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt40(vvv1265, vvv1268, vvv1269)
new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, new_fromInt)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Pos(vvv10330), vvv1047) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, new_fromInt)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Neg(vvv10250), vvv1038) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt29(vvv699, vvv700, vvv703, vvv704) → new_primQuotInt30(vvv699, Succ(vvv700), vvv703, vvv704, Succ(vvv700))
new_primQuotInt33(vvv1265, Succ(vvv12660), Zero, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, new_fromInt)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt21(vvv1020, Zero, vvv102500, Succ(vvv10220), Zero)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt21(vvv1300, Zero, Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt28(vvv1300, vvv1303, vvv1304)
new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)
new_primQuotInt39(vvv436, vvv4410, vvv437, vvv479) → new_primQuotInt17(vvv436, Succ(vvv4410), vvv437, vvv479, Succ(vvv4410))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Neg(vvv12310)) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), new_fromInt)
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), new_fromInt)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Succ(vvv123100))) → new_primQuotInt21(vvv1226, Succ(vvv1227), vvv123100, vvv1228, Succ(vvv1227))

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
QDP
                                              ↳ Rewriting
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Zero), vvv1047) → new_primQuotInt34(vvv1028, vvv10300)
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt26(vvv1300, vvv1303, vvv1304, vvv1319) → new_primQuotInt29(vvv1300, vvv1303, vvv1304, vvv1319)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Succ(vvv119100))) → new_primQuotInt33(vvv1186, Succ(vvv1187), vvv119100, vvv1188, Succ(vvv1187))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Succ(vvv103300)), vvv1047) → new_primQuotInt33(vvv1028, Zero, vvv103300, Succ(vvv10300), Zero)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt37(vvv1186, vvv1188, vvv1187) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), new_fromInt)
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), new_fromInt)
new_primQuotInt32(vvv1265, vvv1268, vvv1269, vvv1291) → new_primQuotInt39(vvv1265, vvv1268, vvv1269, vvv1291)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt40(vvv1265, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, new_fromInt)
new_primQuotInt33(vvv1265, Succ(vvv12660), Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt33(vvv1265, vvv12660, vvv12670, vvv1268, vvv1269)
new_primQuotInt34(vvv1028, vvv10300) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, new_fromInt)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Zero)) → new_primQuotInt37(vvv1186, vvv1188, vvv1187)
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, new_fromInt)
new_primQuotInt33(vvv1265, Zero, Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt40(vvv1265, vvv1268, vvv1269)
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, new_fromInt)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Pos(vvv10330), vvv1047) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, new_fromInt)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Neg(vvv10250), vvv1038) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt29(vvv699, vvv700, vvv703, vvv704) → new_primQuotInt30(vvv699, Succ(vvv700), vvv703, vvv704, Succ(vvv700))
new_primQuotInt33(vvv1265, Succ(vvv12660), Zero, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, new_fromInt)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt21(vvv1020, Zero, vvv102500, Succ(vvv10220), Zero)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)
new_primQuotInt21(vvv1300, Zero, Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt28(vvv1300, vvv1303, vvv1304)
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), new_fromInt)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Neg(vvv12310)) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), new_fromInt)
new_primQuotInt39(vvv436, vvv4410, vvv437, vvv479) → new_primQuotInt17(vvv436, Succ(vvv4410), vvv437, vvv479, Succ(vvv4410))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Succ(vvv123100))) → new_primQuotInt21(vvv1226, Succ(vvv1227), vvv123100, vvv1228, Succ(vvv1227))

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt37(vvv1186, vvv1188, vvv1187) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt37(vvv1186, vvv1188, vvv1187) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
QDP
                                                  ↳ Rewriting
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Zero), vvv1047) → new_primQuotInt34(vvv1028, vvv10300)
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Succ(vvv119100))) → new_primQuotInt33(vvv1186, Succ(vvv1187), vvv119100, vvv1188, Succ(vvv1187))
new_primQuotInt26(vvv1300, vvv1303, vvv1304, vvv1319) → new_primQuotInt29(vvv1300, vvv1303, vvv1304, vvv1319)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Succ(vvv103300)), vvv1047) → new_primQuotInt33(vvv1028, Zero, vvv103300, Succ(vvv10300), Zero)
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), new_fromInt)
new_primQuotInt32(vvv1265, vvv1268, vvv1269, vvv1291) → new_primQuotInt39(vvv1265, vvv1268, vvv1269, vvv1291)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt33(vvv1265, Succ(vvv12660), Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt33(vvv1265, vvv12660, vvv12670, vvv1268, vvv1269)
new_primQuotInt40(vvv1265, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, new_fromInt)
new_primQuotInt34(vvv1028, vvv10300) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, new_fromInt)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Zero)) → new_primQuotInt37(vvv1186, vvv1188, vvv1187)
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, new_fromInt)
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt33(vvv1265, Zero, Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt40(vvv1265, vvv1268, vvv1269)
new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, new_fromInt)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Pos(vvv10330), vvv1047) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, new_fromInt)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Neg(vvv10250), vvv1038) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt29(vvv699, vvv700, vvv703, vvv704) → new_primQuotInt30(vvv699, Succ(vvv700), vvv703, vvv704, Succ(vvv700))
new_primQuotInt37(vvv1186, vvv1188, vvv1187) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt33(vvv1265, Succ(vvv12660), Zero, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, new_fromInt)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt21(vvv1020, Zero, vvv102500, Succ(vvv10220), Zero)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt21(vvv1300, Zero, Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt28(vvv1300, vvv1303, vvv1304)
new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)
new_primQuotInt39(vvv436, vvv4410, vvv437, vvv479) → new_primQuotInt17(vvv436, Succ(vvv4410), vvv437, vvv479, Succ(vvv4410))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Neg(vvv12310)) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), new_fromInt)
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), new_fromInt)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Succ(vvv123100))) → new_primQuotInt21(vvv1226, Succ(vvv1227), vvv123100, vvv1228, Succ(vvv1227))

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
QDP
                                                      ↳ Rewriting
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Zero), vvv1047) → new_primQuotInt34(vvv1028, vvv10300)
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt26(vvv1300, vvv1303, vvv1304, vvv1319) → new_primQuotInt29(vvv1300, vvv1303, vvv1304, vvv1319)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Succ(vvv119100))) → new_primQuotInt33(vvv1186, Succ(vvv1187), vvv119100, vvv1188, Succ(vvv1187))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Succ(vvv103300)), vvv1047) → new_primQuotInt33(vvv1028, Zero, vvv103300, Succ(vvv10300), Zero)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt32(vvv1265, vvv1268, vvv1269, vvv1291) → new_primQuotInt39(vvv1265, vvv1268, vvv1269, vvv1291)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt40(vvv1265, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, new_fromInt)
new_primQuotInt33(vvv1265, Succ(vvv12660), Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt33(vvv1265, vvv12660, vvv12670, vvv1268, vvv1269)
new_primQuotInt34(vvv1028, vvv10300) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, new_fromInt)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Zero)) → new_primQuotInt37(vvv1186, vvv1188, vvv1187)
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, new_fromInt)
new_primQuotInt33(vvv1265, Zero, Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt40(vvv1265, vvv1268, vvv1269)
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, new_fromInt)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Pos(vvv10330), vvv1047) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, new_fromInt)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Neg(vvv10250), vvv1038) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt29(vvv699, vvv700, vvv703, vvv704) → new_primQuotInt30(vvv699, Succ(vvv700), vvv703, vvv704, Succ(vvv700))
new_primQuotInt33(vvv1265, Succ(vvv12660), Zero, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, new_fromInt)
new_primQuotInt37(vvv1186, vvv1188, vvv1187) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt21(vvv1020, Zero, vvv102500, Succ(vvv10220), Zero)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)
new_primQuotInt21(vvv1300, Zero, Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt28(vvv1300, vvv1303, vvv1304)
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), new_fromInt)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Neg(vvv12310)) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), new_fromInt)
new_primQuotInt39(vvv436, vvv4410, vvv437, vvv479) → new_primQuotInt17(vvv436, Succ(vvv4410), vvv437, vvv479, Succ(vvv4410))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Succ(vvv123100))) → new_primQuotInt21(vvv1226, Succ(vvv1227), vvv123100, vvv1228, Succ(vvv1227))

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt40(vvv1265, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt40(vvv1265, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
QDP
                                                          ↳ Rewriting
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Zero), vvv1047) → new_primQuotInt34(vvv1028, vvv10300)
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Succ(vvv119100))) → new_primQuotInt33(vvv1186, Succ(vvv1187), vvv119100, vvv1188, Succ(vvv1187))
new_primQuotInt26(vvv1300, vvv1303, vvv1304, vvv1319) → new_primQuotInt29(vvv1300, vvv1303, vvv1304, vvv1319)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Succ(vvv103300)), vvv1047) → new_primQuotInt33(vvv1028, Zero, vvv103300, Succ(vvv10300), Zero)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt32(vvv1265, vvv1268, vvv1269, vvv1291) → new_primQuotInt39(vvv1265, vvv1268, vvv1269, vvv1291)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt33(vvv1265, Succ(vvv12660), Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt33(vvv1265, vvv12660, vvv12670, vvv1268, vvv1269)
new_primQuotInt34(vvv1028, vvv10300) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, new_fromInt)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Zero)) → new_primQuotInt37(vvv1186, vvv1188, vvv1187)
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, new_fromInt)
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt33(vvv1265, Zero, Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt40(vvv1265, vvv1268, vvv1269)
new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, new_fromInt)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Pos(vvv10330), vvv1047) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, new_fromInt)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Neg(vvv10250), vvv1038) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt29(vvv699, vvv700, vvv703, vvv704) → new_primQuotInt30(vvv699, Succ(vvv700), vvv703, vvv704, Succ(vvv700))
new_primQuotInt37(vvv1186, vvv1188, vvv1187) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt33(vvv1265, Succ(vvv12660), Zero, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, new_fromInt)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt21(vvv1020, Zero, vvv102500, Succ(vvv10220), Zero)
new_primQuotInt40(vvv1265, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, Pos(Zero))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt21(vvv1300, Zero, Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt28(vvv1300, vvv1303, vvv1304)
new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)
new_primQuotInt39(vvv436, vvv4410, vvv437, vvv479) → new_primQuotInt17(vvv436, Succ(vvv4410), vvv437, vvv479, Succ(vvv4410))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Neg(vvv12310)) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), new_fromInt)
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), new_fromInt)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Succ(vvv123100))) → new_primQuotInt21(vvv1226, Succ(vvv1227), vvv123100, vvv1228, Succ(vvv1227))

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt34(vvv1028, vvv10300) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt34(vvv1028, vvv10300) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
QDP
                                                              ↳ Rewriting
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Zero), vvv1047) → new_primQuotInt34(vvv1028, vvv10300)
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt26(vvv1300, vvv1303, vvv1304, vvv1319) → new_primQuotInt29(vvv1300, vvv1303, vvv1304, vvv1319)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Succ(vvv119100))) → new_primQuotInt33(vvv1186, Succ(vvv1187), vvv119100, vvv1188, Succ(vvv1187))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Succ(vvv103300)), vvv1047) → new_primQuotInt33(vvv1028, Zero, vvv103300, Succ(vvv10300), Zero)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt34(vvv1028, vvv10300) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt32(vvv1265, vvv1268, vvv1269, vvv1291) → new_primQuotInt39(vvv1265, vvv1268, vvv1269, vvv1291)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt33(vvv1265, Succ(vvv12660), Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt33(vvv1265, vvv12660, vvv12670, vvv1268, vvv1269)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Zero)) → new_primQuotInt37(vvv1186, vvv1188, vvv1187)
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, new_fromInt)
new_primQuotInt33(vvv1265, Zero, Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt40(vvv1265, vvv1268, vvv1269)
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, new_fromInt)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Pos(vvv10330), vvv1047) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, new_fromInt)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Neg(vvv10250), vvv1038) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt29(vvv699, vvv700, vvv703, vvv704) → new_primQuotInt30(vvv699, Succ(vvv700), vvv703, vvv704, Succ(vvv700))
new_primQuotInt33(vvv1265, Succ(vvv12660), Zero, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, new_fromInt)
new_primQuotInt37(vvv1186, vvv1188, vvv1187) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt21(vvv1020, Zero, vvv102500, Succ(vvv10220), Zero)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt40(vvv1265, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, Pos(Zero))
new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)
new_primQuotInt21(vvv1300, Zero, Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt28(vvv1300, vvv1303, vvv1304)
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), new_fromInt)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Neg(vvv12310)) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), new_fromInt)
new_primQuotInt39(vvv436, vvv4410, vvv437, vvv479) → new_primQuotInt17(vvv436, Succ(vvv4410), vvv437, vvv479, Succ(vvv4410))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Succ(vvv123100))) → new_primQuotInt21(vvv1226, Succ(vvv1227), vvv123100, vvv1228, Succ(vvv1227))

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
QDP
                                                                  ↳ Rewriting
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Zero), vvv1047) → new_primQuotInt34(vvv1028, vvv10300)
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Succ(vvv119100))) → new_primQuotInt33(vvv1186, Succ(vvv1187), vvv119100, vvv1188, Succ(vvv1187))
new_primQuotInt26(vvv1300, vvv1303, vvv1304, vvv1319) → new_primQuotInt29(vvv1300, vvv1303, vvv1304, vvv1319)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Succ(vvv103300)), vvv1047) → new_primQuotInt33(vvv1028, Zero, vvv103300, Succ(vvv10300), Zero)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt34(vvv1028, vvv10300) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt32(vvv1265, vvv1268, vvv1269, vvv1291) → new_primQuotInt39(vvv1265, vvv1268, vvv1269, vvv1291)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt33(vvv1265, Succ(vvv12660), Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt33(vvv1265, vvv12660, vvv12670, vvv1268, vvv1269)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Zero)) → new_primQuotInt37(vvv1186, vvv1188, vvv1187)
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt33(vvv1265, Zero, Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt40(vvv1265, vvv1268, vvv1269)
new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, new_fromInt)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Pos(vvv10330), vvv1047) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, new_fromInt)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Neg(vvv10250), vvv1038) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt29(vvv699, vvv700, vvv703, vvv704) → new_primQuotInt30(vvv699, Succ(vvv700), vvv703, vvv704, Succ(vvv700))
new_primQuotInt37(vvv1186, vvv1188, vvv1187) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt33(vvv1265, Succ(vvv12660), Zero, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, new_fromInt)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt21(vvv1020, Zero, vvv102500, Succ(vvv10220), Zero)
new_primQuotInt40(vvv1265, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, Pos(Zero))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, Pos(Zero))
new_primQuotInt21(vvv1300, Zero, Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt28(vvv1300, vvv1303, vvv1304)
new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)
new_primQuotInt39(vvv436, vvv4410, vvv437, vvv479) → new_primQuotInt17(vvv436, Succ(vvv4410), vvv437, vvv479, Succ(vvv4410))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Neg(vvv12310)) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), new_fromInt)
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), new_fromInt)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Succ(vvv123100))) → new_primQuotInt21(vvv1226, Succ(vvv1227), vvv123100, vvv1228, Succ(vvv1227))

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
QDP
                                                                      ↳ Rewriting
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Zero), vvv1047) → new_primQuotInt34(vvv1028, vvv10300)
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt26(vvv1300, vvv1303, vvv1304, vvv1319) → new_primQuotInt29(vvv1300, vvv1303, vvv1304, vvv1319)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Succ(vvv119100))) → new_primQuotInt33(vvv1186, Succ(vvv1187), vvv119100, vvv1188, Succ(vvv1187))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Succ(vvv103300)), vvv1047) → new_primQuotInt33(vvv1028, Zero, vvv103300, Succ(vvv10300), Zero)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt34(vvv1028, vvv10300) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt32(vvv1265, vvv1268, vvv1269, vvv1291) → new_primQuotInt39(vvv1265, vvv1268, vvv1269, vvv1291)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt33(vvv1265, Succ(vvv12660), Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt33(vvv1265, vvv12660, vvv12670, vvv1268, vvv1269)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Zero)) → new_primQuotInt37(vvv1186, vvv1188, vvv1187)
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt33(vvv1265, Zero, Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt40(vvv1265, vvv1268, vvv1269)
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Pos(vvv10330), vvv1047) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, new_fromInt)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Neg(vvv10250), vvv1038) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt29(vvv699, vvv700, vvv703, vvv704) → new_primQuotInt30(vvv699, Succ(vvv700), vvv703, vvv704, Succ(vvv700))
new_primQuotInt33(vvv1265, Succ(vvv12660), Zero, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, new_fromInt)
new_primQuotInt37(vvv1186, vvv1188, vvv1187) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt21(vvv1020, Zero, vvv102500, Succ(vvv10220), Zero)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt40(vvv1265, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, Pos(Zero))
new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)
new_primQuotInt21(vvv1300, Zero, Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt28(vvv1300, vvv1303, vvv1304)
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, Pos(Zero))
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), new_fromInt)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Neg(vvv12310)) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), new_fromInt)
new_primQuotInt39(vvv436, vvv4410, vvv437, vvv479) → new_primQuotInt17(vvv436, Succ(vvv4410), vvv437, vvv479, Succ(vvv4410))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Succ(vvv123100))) → new_primQuotInt21(vvv1226, Succ(vvv1227), vvv123100, vvv1228, Succ(vvv1227))

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Pos(vvv10330), vvv1047) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Pos(vvv10330), vvv1047) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
QDP
                                                                          ↳ Rewriting
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Zero), vvv1047) → new_primQuotInt34(vvv1028, vvv10300)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Pos(vvv10330), vvv1047) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Succ(vvv119100))) → new_primQuotInt33(vvv1186, Succ(vvv1187), vvv119100, vvv1188, Succ(vvv1187))
new_primQuotInt26(vvv1300, vvv1303, vvv1304, vvv1319) → new_primQuotInt29(vvv1300, vvv1303, vvv1304, vvv1319)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Succ(vvv103300)), vvv1047) → new_primQuotInt33(vvv1028, Zero, vvv103300, Succ(vvv10300), Zero)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt34(vvv1028, vvv10300) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt32(vvv1265, vvv1268, vvv1269, vvv1291) → new_primQuotInt39(vvv1265, vvv1268, vvv1269, vvv1291)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt33(vvv1265, Succ(vvv12660), Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt33(vvv1265, vvv12660, vvv12670, vvv1268, vvv1269)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Zero)) → new_primQuotInt37(vvv1186, vvv1188, vvv1187)
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt33(vvv1265, Zero, Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt40(vvv1265, vvv1268, vvv1269)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Neg(vvv10250), vvv1038) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt29(vvv699, vvv700, vvv703, vvv704) → new_primQuotInt30(vvv699, Succ(vvv700), vvv703, vvv704, Succ(vvv700))
new_primQuotInt37(vvv1186, vvv1188, vvv1187) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt33(vvv1265, Succ(vvv12660), Zero, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, new_fromInt)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt21(vvv1020, Zero, vvv102500, Succ(vvv10220), Zero)
new_primQuotInt40(vvv1265, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, Pos(Zero))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, Pos(Zero))
new_primQuotInt21(vvv1300, Zero, Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt28(vvv1300, vvv1303, vvv1304)
new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)
new_primQuotInt39(vvv436, vvv4410, vvv437, vvv479) → new_primQuotInt17(vvv436, Succ(vvv4410), vvv437, vvv479, Succ(vvv4410))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Neg(vvv12310)) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), new_fromInt)
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), new_fromInt)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Succ(vvv123100))) → new_primQuotInt21(vvv1226, Succ(vvv1227), vvv123100, vvv1228, Succ(vvv1227))

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt33(vvv1265, Succ(vvv12660), Zero, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt33(vvv1265, Succ(vvv12660), Zero, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
QDP
                                                                              ↳ Rewriting
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Zero), vvv1047) → new_primQuotInt34(vvv1028, vvv10300)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Pos(vvv10330), vvv1047) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt26(vvv1300, vvv1303, vvv1304, vvv1319) → new_primQuotInt29(vvv1300, vvv1303, vvv1304, vvv1319)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Succ(vvv119100))) → new_primQuotInt33(vvv1186, Succ(vvv1187), vvv119100, vvv1188, Succ(vvv1187))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Succ(vvv103300)), vvv1047) → new_primQuotInt33(vvv1028, Zero, vvv103300, Succ(vvv10300), Zero)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt34(vvv1028, vvv10300) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt32(vvv1265, vvv1268, vvv1269, vvv1291) → new_primQuotInt39(vvv1265, vvv1268, vvv1269, vvv1291)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt33(vvv1265, Succ(vvv12660), Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt33(vvv1265, vvv12660, vvv12670, vvv1268, vvv1269)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Zero)) → new_primQuotInt37(vvv1186, vvv1188, vvv1187)
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt33(vvv1265, Zero, Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt40(vvv1265, vvv1268, vvv1269)
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Neg(vvv10250), vvv1038) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt29(vvv699, vvv700, vvv703, vvv704) → new_primQuotInt30(vvv699, Succ(vvv700), vvv703, vvv704, Succ(vvv700))
new_primQuotInt37(vvv1186, vvv1188, vvv1187) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt21(vvv1020, Zero, vvv102500, Succ(vvv10220), Zero)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt40(vvv1265, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, Pos(Zero))
new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)
new_primQuotInt21(vvv1300, Zero, Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt28(vvv1300, vvv1303, vvv1304)
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, Pos(Zero))
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), new_fromInt)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Neg(vvv12310)) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), new_fromInt)
new_primQuotInt39(vvv436, vvv4410, vvv437, vvv479) → new_primQuotInt17(vvv436, Succ(vvv4410), vvv437, vvv479, Succ(vvv4410))
new_primQuotInt33(vvv1265, Succ(vvv12660), Zero, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Succ(vvv123100))) → new_primQuotInt21(vvv1226, Succ(vvv1227), vvv123100, vvv1228, Succ(vvv1227))

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
QDP
                                                                                  ↳ Rewriting
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Zero), vvv1047) → new_primQuotInt34(vvv1028, vvv10300)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Pos(vvv10330), vvv1047) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Succ(vvv119100))) → new_primQuotInt33(vvv1186, Succ(vvv1187), vvv119100, vvv1188, Succ(vvv1187))
new_primQuotInt26(vvv1300, vvv1303, vvv1304, vvv1319) → new_primQuotInt29(vvv1300, vvv1303, vvv1304, vvv1319)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Succ(vvv103300)), vvv1047) → new_primQuotInt33(vvv1028, Zero, vvv103300, Succ(vvv10300), Zero)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt34(vvv1028, vvv10300) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt32(vvv1265, vvv1268, vvv1269, vvv1291) → new_primQuotInt39(vvv1265, vvv1268, vvv1269, vvv1291)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt33(vvv1265, Succ(vvv12660), Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt33(vvv1265, vvv12660, vvv12670, vvv1268, vvv1269)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Zero)) → new_primQuotInt37(vvv1186, vvv1188, vvv1187)
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt33(vvv1265, Zero, Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt40(vvv1265, vvv1268, vvv1269)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Neg(vvv10250), vvv1038) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt29(vvv699, vvv700, vvv703, vvv704) → new_primQuotInt30(vvv699, Succ(vvv700), vvv703, vvv704, Succ(vvv700))
new_primQuotInt37(vvv1186, vvv1188, vvv1187) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt21(vvv1020, Zero, vvv102500, Succ(vvv10220), Zero)
new_primQuotInt40(vvv1265, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, Pos(Zero))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, Pos(Zero))
new_primQuotInt21(vvv1300, Zero, Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt28(vvv1300, vvv1303, vvv1304)
new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)
new_primQuotInt39(vvv436, vvv4410, vvv437, vvv479) → new_primQuotInt17(vvv436, Succ(vvv4410), vvv437, vvv479, Succ(vvv4410))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Neg(vvv12310)) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), new_fromInt)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Succ(vvv123100))) → new_primQuotInt21(vvv1226, Succ(vvv1227), vvv123100, vvv1228, Succ(vvv1227))
new_primQuotInt33(vvv1265, Succ(vvv12660), Zero, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, Pos(Zero))

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Neg(vvv12310)) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Neg(vvv12310)) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
QDP
                                                                                      ↳ UsableRulesProof
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Zero), vvv1047) → new_primQuotInt34(vvv1028, vvv10300)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Pos(vvv10330), vvv1047) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt26(vvv1300, vvv1303, vvv1304, vvv1319) → new_primQuotInt29(vvv1300, vvv1303, vvv1304, vvv1319)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Succ(vvv119100))) → new_primQuotInt33(vvv1186, Succ(vvv1187), vvv119100, vvv1188, Succ(vvv1187))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Succ(vvv103300)), vvv1047) → new_primQuotInt33(vvv1028, Zero, vvv103300, Succ(vvv10300), Zero)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt34(vvv1028, vvv10300) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt32(vvv1265, vvv1268, vvv1269, vvv1291) → new_primQuotInt39(vvv1265, vvv1268, vvv1269, vvv1291)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt33(vvv1265, Succ(vvv12660), Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt33(vvv1265, vvv12660, vvv12670, vvv1268, vvv1269)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Zero)) → new_primQuotInt37(vvv1186, vvv1188, vvv1187)
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt33(vvv1265, Zero, Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt40(vvv1265, vvv1268, vvv1269)
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Neg(vvv10250), vvv1038) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt29(vvv699, vvv700, vvv703, vvv704) → new_primQuotInt30(vvv699, Succ(vvv700), vvv703, vvv704, Succ(vvv700))
new_primQuotInt37(vvv1186, vvv1188, vvv1187) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt21(vvv1020, Zero, vvv102500, Succ(vvv10220), Zero)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt40(vvv1265, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, Pos(Zero))
new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)
new_primQuotInt21(vvv1300, Zero, Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt28(vvv1300, vvv1303, vvv1304)
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Neg(vvv12310)) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt39(vvv436, vvv4410, vvv437, vvv479) → new_primQuotInt17(vvv436, Succ(vvv4410), vvv437, vvv479, Succ(vvv4410))
new_primQuotInt33(vvv1265, Succ(vvv12660), Zero, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Succ(vvv123100))) → new_primQuotInt21(vvv1226, Succ(vvv1227), vvv123100, vvv1228, Succ(vvv1227))

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
QDP
                                                                                          ↳ QReductionProof
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Zero), vvv1047) → new_primQuotInt34(vvv1028, vvv10300)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Pos(vvv10330), vvv1047) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Succ(vvv119100))) → new_primQuotInt33(vvv1186, Succ(vvv1187), vvv119100, vvv1188, Succ(vvv1187))
new_primQuotInt26(vvv1300, vvv1303, vvv1304, vvv1319) → new_primQuotInt29(vvv1300, vvv1303, vvv1304, vvv1319)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Succ(vvv103300)), vvv1047) → new_primQuotInt33(vvv1028, Zero, vvv103300, Succ(vvv10300), Zero)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt34(vvv1028, vvv10300) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt32(vvv1265, vvv1268, vvv1269, vvv1291) → new_primQuotInt39(vvv1265, vvv1268, vvv1269, vvv1291)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt33(vvv1265, Succ(vvv12660), Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt33(vvv1265, vvv12660, vvv12670, vvv1268, vvv1269)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Zero)) → new_primQuotInt37(vvv1186, vvv1188, vvv1187)
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt33(vvv1265, Zero, Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt40(vvv1265, vvv1268, vvv1269)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Neg(vvv10250), vvv1038) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt29(vvv699, vvv700, vvv703, vvv704) → new_primQuotInt30(vvv699, Succ(vvv700), vvv703, vvv704, Succ(vvv700))
new_primQuotInt37(vvv1186, vvv1188, vvv1187) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt21(vvv1020, Zero, vvv102500, Succ(vvv10220), Zero)
new_primQuotInt40(vvv1265, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, Pos(Zero))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, Pos(Zero))
new_primQuotInt21(vvv1300, Zero, Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt28(vvv1300, vvv1303, vvv1304)
new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Neg(vvv12310)) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt39(vvv436, vvv4410, vvv437, vvv479) → new_primQuotInt17(vvv436, Succ(vvv4410), vvv437, vvv479, Succ(vvv4410))
new_primQuotInt33(vvv1265, Succ(vvv12660), Zero, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Succ(vvv123100))) → new_primQuotInt21(vvv1226, Succ(vvv1227), vvv123100, vvv1228, Succ(vvv1227))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_fromInt



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
QDP
                                                                                              ↳ Instantiation
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Zero), vvv1047) → new_primQuotInt34(vvv1028, vvv10300)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Pos(vvv10330), vvv1047) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt26(vvv1300, vvv1303, vvv1304, vvv1319) → new_primQuotInt29(vvv1300, vvv1303, vvv1304, vvv1319)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Succ(vvv119100))) → new_primQuotInt33(vvv1186, Succ(vvv1187), vvv119100, vvv1188, Succ(vvv1187))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Succ(vvv103300)), vvv1047) → new_primQuotInt33(vvv1028, Zero, vvv103300, Succ(vvv10300), Zero)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt34(vvv1028, vvv10300) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt32(vvv1265, vvv1268, vvv1269, vvv1291) → new_primQuotInt39(vvv1265, vvv1268, vvv1269, vvv1291)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt33(vvv1265, Succ(vvv12660), Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt33(vvv1265, vvv12660, vvv12670, vvv1268, vvv1269)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Zero)) → new_primQuotInt37(vvv1186, vvv1188, vvv1187)
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt33(vvv1265, Zero, Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt40(vvv1265, vvv1268, vvv1269)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Neg(vvv10250), vvv1038) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt29(vvv699, vvv700, vvv703, vvv704) → new_primQuotInt30(vvv699, Succ(vvv700), vvv703, vvv704, Succ(vvv700))
new_primQuotInt37(vvv1186, vvv1188, vvv1187) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt21(vvv1020, Zero, vvv102500, Succ(vvv10220), Zero)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt40(vvv1265, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, Pos(Zero))
new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)
new_primQuotInt21(vvv1300, Zero, Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt28(vvv1300, vvv1303, vvv1304)
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, Pos(Zero))
new_primQuotInt39(vvv436, vvv4410, vvv437, vvv479) → new_primQuotInt17(vvv436, Succ(vvv4410), vvv437, vvv479, Succ(vvv4410))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Neg(vvv12310)) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Succ(vvv123100))) → new_primQuotInt21(vvv1226, Succ(vvv1227), vvv123100, vvv1228, Succ(vvv1227))
new_primQuotInt33(vvv1265, Succ(vvv12660), Zero, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt26(vvv1300, vvv1303, vvv1304, vvv1319) → new_primQuotInt29(vvv1300, vvv1303, vvv1304, vvv1319) we obtained the following new rules:

new_primQuotInt26(z0, z1, Zero, Pos(Zero)) → new_primQuotInt29(z0, z1, Zero, Pos(Zero))
new_primQuotInt26(z0, z1, z2, Pos(Zero)) → new_primQuotInt29(z0, z1, z2, Pos(Zero))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
QDP
                                                                                                  ↳ Instantiation
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Zero), vvv1047) → new_primQuotInt34(vvv1028, vvv10300)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Pos(vvv10330), vvv1047) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Succ(vvv119100))) → new_primQuotInt33(vvv1186, Succ(vvv1187), vvv119100, vvv1188, Succ(vvv1187))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Succ(vvv103300)), vvv1047) → new_primQuotInt33(vvv1028, Zero, vvv103300, Succ(vvv10300), Zero)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt34(vvv1028, vvv10300) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt32(vvv1265, vvv1268, vvv1269, vvv1291) → new_primQuotInt39(vvv1265, vvv1268, vvv1269, vvv1291)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt33(vvv1265, Succ(vvv12660), Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt33(vvv1265, vvv12660, vvv12670, vvv1268, vvv1269)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Zero)) → new_primQuotInt37(vvv1186, vvv1188, vvv1187)
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt33(vvv1265, Zero, Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt40(vvv1265, vvv1268, vvv1269)
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Neg(vvv10250), vvv1038) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt29(vvv699, vvv700, vvv703, vvv704) → new_primQuotInt30(vvv699, Succ(vvv700), vvv703, vvv704, Succ(vvv700))
new_primQuotInt37(vvv1186, vvv1188, vvv1187) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt21(vvv1020, Zero, vvv102500, Succ(vvv10220), Zero)
new_primQuotInt26(z0, z1, Zero, Pos(Zero)) → new_primQuotInt29(z0, z1, Zero, Pos(Zero))
new_primQuotInt40(vvv1265, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, Pos(Zero))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, Pos(Zero))
new_primQuotInt21(vvv1300, Zero, Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt28(vvv1300, vvv1303, vvv1304)
new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)
new_primQuotInt26(z0, z1, z2, Pos(Zero)) → new_primQuotInt29(z0, z1, z2, Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Neg(vvv12310)) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt39(vvv436, vvv4410, vvv437, vvv479) → new_primQuotInt17(vvv436, Succ(vvv4410), vvv437, vvv479, Succ(vvv4410))
new_primQuotInt33(vvv1265, Succ(vvv12660), Zero, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Succ(vvv123100))) → new_primQuotInt21(vvv1226, Succ(vvv1227), vvv123100, vvv1228, Succ(vvv1227))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt32(vvv1265, vvv1268, vvv1269, vvv1291) → new_primQuotInt39(vvv1265, vvv1268, vvv1269, vvv1291) we obtained the following new rules:

new_primQuotInt32(z0, z1, z2, Pos(Zero)) → new_primQuotInt39(z0, z1, z2, Pos(Zero))
new_primQuotInt32(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt39(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt32(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt39(z0, Succ(z1), Zero, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
QDP
                                                                                                      ↳ Instantiation
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt32(z0, z1, z2, Pos(Zero)) → new_primQuotInt39(z0, z1, z2, Pos(Zero))
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Zero), vvv1047) → new_primQuotInt34(vvv1028, vvv10300)
new_primQuotInt32(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt39(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Pos(vvv10330), vvv1047) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Succ(vvv119100))) → new_primQuotInt33(vvv1186, Succ(vvv1187), vvv119100, vvv1188, Succ(vvv1187))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Succ(vvv103300)), vvv1047) → new_primQuotInt33(vvv1028, Zero, vvv103300, Succ(vvv10300), Zero)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt34(vvv1028, vvv10300) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt33(vvv1265, Succ(vvv12660), Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt33(vvv1265, vvv12660, vvv12670, vvv1268, vvv1269)
new_primQuotInt32(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt39(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Zero)) → new_primQuotInt37(vvv1186, vvv1188, vvv1187)
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt33(vvv1265, Zero, Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt40(vvv1265, vvv1268, vvv1269)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Neg(vvv10250), vvv1038) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt29(vvv699, vvv700, vvv703, vvv704) → new_primQuotInt30(vvv699, Succ(vvv700), vvv703, vvv704, Succ(vvv700))
new_primQuotInt37(vvv1186, vvv1188, vvv1187) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt21(vvv1020, Zero, vvv102500, Succ(vvv10220), Zero)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt40(vvv1265, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, Pos(Zero))
new_primQuotInt26(z0, z1, Zero, Pos(Zero)) → new_primQuotInt29(z0, z1, Zero, Pos(Zero))
new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)
new_primQuotInt21(vvv1300, Zero, Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt28(vvv1300, vvv1303, vvv1304)
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, Pos(Zero))
new_primQuotInt26(z0, z1, z2, Pos(Zero)) → new_primQuotInt29(z0, z1, z2, Pos(Zero))
new_primQuotInt39(vvv436, vvv4410, vvv437, vvv479) → new_primQuotInt17(vvv436, Succ(vvv4410), vvv437, vvv479, Succ(vvv4410))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Neg(vvv12310)) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Succ(vvv123100))) → new_primQuotInt21(vvv1226, Succ(vvv1227), vvv123100, vvv1228, Succ(vvv1227))
new_primQuotInt33(vvv1265, Succ(vvv12660), Zero, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt29(vvv699, vvv700, vvv703, vvv704) → new_primQuotInt30(vvv699, Succ(vvv700), vvv703, vvv704, Succ(vvv700)) we obtained the following new rules:

new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt29(z0, z1, z2, Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt29(z0, z1, Zero, Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Zero, Pos(Zero), Succ(z1))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
QDP
                                                                                                          ↳ DependencyGraphProof
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt32(z0, z1, z2, Pos(Zero)) → new_primQuotInt39(z0, z1, z2, Pos(Zero))
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Zero), vvv1047) → new_primQuotInt34(vvv1028, vvv10300)
new_primQuotInt29(z0, z1, z2, Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Pos(vvv10330), vvv1047) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))
new_primQuotInt32(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt39(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Succ(vvv119100))) → new_primQuotInt33(vvv1186, Succ(vvv1187), vvv119100, vvv1188, Succ(vvv1187))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Succ(vvv103300)), vvv1047) → new_primQuotInt33(vvv1028, Zero, vvv103300, Succ(vvv10300), Zero)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt34(vvv1028, vvv10300) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt33(vvv1265, Succ(vvv12660), Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt33(vvv1265, vvv12660, vvv12670, vvv1268, vvv1269)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Zero)) → new_primQuotInt37(vvv1186, vvv1188, vvv1187)
new_primQuotInt32(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt39(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt33(vvv1265, Zero, Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt40(vvv1265, vvv1268, vvv1269)
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Neg(vvv10250), vvv1038) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt37(vvv1186, vvv1188, vvv1187) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt21(vvv1020, Zero, vvv102500, Succ(vvv10220), Zero)
new_primQuotInt26(z0, z1, Zero, Pos(Zero)) → new_primQuotInt29(z0, z1, Zero, Pos(Zero))
new_primQuotInt40(vvv1265, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, Pos(Zero))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt29(z0, z1, Zero, Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Zero, Pos(Zero), Succ(z1))
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, Pos(Zero))
new_primQuotInt21(vvv1300, Zero, Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt28(vvv1300, vvv1303, vvv1304)
new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)
new_primQuotInt26(z0, z1, z2, Pos(Zero)) → new_primQuotInt29(z0, z1, z2, Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Neg(vvv12310)) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt39(vvv436, vvv4410, vvv437, vvv479) → new_primQuotInt17(vvv436, Succ(vvv4410), vvv437, vvv479, Succ(vvv4410))
new_primQuotInt33(vvv1265, Succ(vvv12660), Zero, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Succ(vvv123100))) → new_primQuotInt21(vvv1226, Succ(vvv1227), vvv123100, vvv1228, Succ(vvv1227))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
QDP
                                                                                                              ↳ Instantiation
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt32(z0, z1, z2, Pos(Zero)) → new_primQuotInt39(z0, z1, z2, Pos(Zero))
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Zero), vvv1047) → new_primQuotInt34(vvv1028, vvv10300)
new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt29(z0, z1, z2, Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt32(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt39(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Pos(vvv10330), vvv1047) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Succ(vvv119100))) → new_primQuotInt33(vvv1186, Succ(vvv1187), vvv119100, vvv1188, Succ(vvv1187))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Succ(vvv103300)), vvv1047) → new_primQuotInt33(vvv1028, Zero, vvv103300, Succ(vvv10300), Zero)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt34(vvv1028, vvv10300) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt33(vvv1265, Succ(vvv12660), Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt33(vvv1265, vvv12660, vvv12670, vvv1268, vvv1269)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Zero)) → new_primQuotInt37(vvv1186, vvv1188, vvv1187)
new_primQuotInt32(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt39(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt33(vvv1265, Zero, Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt40(vvv1265, vvv1268, vvv1269)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Neg(vvv10250), vvv1038) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt37(vvv1186, vvv1188, vvv1187) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt21(vvv1020, Zero, vvv102500, Succ(vvv10220), Zero)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt26(z0, z1, Zero, Pos(Zero)) → new_primQuotInt29(z0, z1, Zero, Pos(Zero))
new_primQuotInt40(vvv1265, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, Pos(Zero))
new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)
new_primQuotInt21(vvv1300, Zero, Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt28(vvv1300, vvv1303, vvv1304)
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, Pos(Zero))
new_primQuotInt26(z0, z1, z2, Pos(Zero)) → new_primQuotInt29(z0, z1, z2, Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Neg(vvv12310)) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt39(vvv436, vvv4410, vvv437, vvv479) → new_primQuotInt17(vvv436, Succ(vvv4410), vvv437, vvv479, Succ(vvv4410))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Succ(vvv123100))) → new_primQuotInt21(vvv1226, Succ(vvv1227), vvv123100, vvv1228, Succ(vvv1227))
new_primQuotInt33(vvv1265, Succ(vvv12660), Zero, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt39(vvv436, vvv4410, vvv437, vvv479) → new_primQuotInt17(vvv436, Succ(vvv4410), vvv437, vvv479, Succ(vvv4410)) we obtained the following new rules:

new_primQuotInt39(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt17(z0, Succ(Succ(z1)), Zero, Pos(Zero), Succ(Succ(z1)))
new_primQuotInt39(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt39(z0, z1, z2, Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), z2, Pos(Zero), Succ(z1))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
QDP
                                                                                                                  ↳ DependencyGraphProof
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt32(z0, z1, z2, Pos(Zero)) → new_primQuotInt39(z0, z1, z2, Pos(Zero))
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Zero), vvv1047) → new_primQuotInt34(vvv1028, vvv10300)
new_primQuotInt29(z0, z1, z2, Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Pos(vvv10330), vvv1047) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))
new_primQuotInt32(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt39(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Succ(vvv119100))) → new_primQuotInt33(vvv1186, Succ(vvv1187), vvv119100, vvv1188, Succ(vvv1187))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Succ(vvv103300)), vvv1047) → new_primQuotInt33(vvv1028, Zero, vvv103300, Succ(vvv10300), Zero)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt34(vvv1028, vvv10300) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))
new_primQuotInt39(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt17(z0, Succ(Succ(z1)), Zero, Pos(Zero), Succ(Succ(z1)))
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt33(vvv1265, Succ(vvv12660), Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt33(vvv1265, vvv12660, vvv12670, vvv1268, vvv1269)
new_primQuotInt32(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt39(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Zero)) → new_primQuotInt37(vvv1186, vvv1188, vvv1187)
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt39(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt33(vvv1265, Zero, Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt40(vvv1265, vvv1268, vvv1269)
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Neg(vvv10250), vvv1038) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt37(vvv1186, vvv1188, vvv1187) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt21(vvv1020, Zero, vvv102500, Succ(vvv10220), Zero)
new_primQuotInt40(vvv1265, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, Pos(Zero))
new_primQuotInt26(z0, z1, Zero, Pos(Zero)) → new_primQuotInt29(z0, z1, Zero, Pos(Zero))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, Pos(Zero))
new_primQuotInt21(vvv1300, Zero, Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt28(vvv1300, vvv1303, vvv1304)
new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)
new_primQuotInt26(z0, z1, z2, Pos(Zero)) → new_primQuotInt29(z0, z1, z2, Pos(Zero))
new_primQuotInt39(z0, z1, z2, Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Neg(vvv12310)) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt33(vvv1265, Succ(vvv12660), Zero, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Succ(vvv123100))) → new_primQuotInt21(vvv1226, Succ(vvv1227), vvv123100, vvv1228, Succ(vvv1227))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
QDP
                                                                                                                      ↳ QDPOrderProof
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt32(z0, z1, z2, Pos(Zero)) → new_primQuotInt39(z0, z1, z2, Pos(Zero))
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Zero), vvv1047) → new_primQuotInt34(vvv1028, vvv10300)
new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt29(z0, z1, z2, Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Pos(vvv10330), vvv1047) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))
new_primQuotInt32(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt39(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Succ(vvv119100))) → new_primQuotInt33(vvv1186, Succ(vvv1187), vvv119100, vvv1188, Succ(vvv1187))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Succ(vvv103300)), vvv1047) → new_primQuotInt33(vvv1028, Zero, vvv103300, Succ(vvv10300), Zero)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt34(vvv1028, vvv10300) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt33(vvv1265, Succ(vvv12660), Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt33(vvv1265, vvv12660, vvv12670, vvv1268, vvv1269)
new_primQuotInt32(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt39(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Zero)) → new_primQuotInt37(vvv1186, vvv1188, vvv1187)
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt39(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt33(vvv1265, Zero, Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt40(vvv1265, vvv1268, vvv1269)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Neg(vvv10250), vvv1038) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt37(vvv1186, vvv1188, vvv1187) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt21(vvv1020, Zero, vvv102500, Succ(vvv10220), Zero)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt26(z0, z1, Zero, Pos(Zero)) → new_primQuotInt29(z0, z1, Zero, Pos(Zero))
new_primQuotInt40(vvv1265, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, Pos(Zero))
new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)
new_primQuotInt21(vvv1300, Zero, Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt28(vvv1300, vvv1303, vvv1304)
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, Pos(Zero))
new_primQuotInt26(z0, z1, z2, Pos(Zero)) → new_primQuotInt29(z0, z1, z2, Pos(Zero))
new_primQuotInt39(z0, z1, z2, Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Neg(vvv12310)) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Succ(vvv123100))) → new_primQuotInt21(vvv1226, Succ(vvv1227), vvv123100, vvv1228, Succ(vvv1227))
new_primQuotInt33(vvv1265, Succ(vvv12660), Zero, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Succ(vvv119100))) → new_primQuotInt33(vvv1186, Succ(vvv1187), vvv119100, vvv1188, Succ(vvv1187))
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Succ(vvv103300)), vvv1047) → new_primQuotInt33(vvv1028, Zero, vvv103300, Succ(vvv10300), Zero)
new_primQuotInt34(vvv1028, vvv10300) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))
new_primQuotInt37(vvv1186, vvv1188, vvv1187) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
The remaining pairs can at least be oriented weakly.

new_primQuotInt32(z0, z1, z2, Pos(Zero)) → new_primQuotInt39(z0, z1, z2, Pos(Zero))
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Zero), vvv1047) → new_primQuotInt34(vvv1028, vvv10300)
new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt29(z0, z1, z2, Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Pos(vvv10330), vvv1047) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))
new_primQuotInt32(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt39(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt33(vvv1265, Succ(vvv12660), Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt33(vvv1265, vvv12660, vvv12670, vvv1268, vvv1269)
new_primQuotInt32(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt39(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Zero)) → new_primQuotInt37(vvv1186, vvv1188, vvv1187)
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt39(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt33(vvv1265, Zero, Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt40(vvv1265, vvv1268, vvv1269)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Neg(vvv10250), vvv1038) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt21(vvv1020, Zero, vvv102500, Succ(vvv10220), Zero)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt26(z0, z1, Zero, Pos(Zero)) → new_primQuotInt29(z0, z1, Zero, Pos(Zero))
new_primQuotInt40(vvv1265, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, Pos(Zero))
new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)
new_primQuotInt21(vvv1300, Zero, Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt28(vvv1300, vvv1303, vvv1304)
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, Pos(Zero))
new_primQuotInt26(z0, z1, z2, Pos(Zero)) → new_primQuotInt29(z0, z1, z2, Pos(Zero))
new_primQuotInt39(z0, z1, z2, Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Neg(vvv12310)) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Succ(vvv123100))) → new_primQuotInt21(vvv1226, Succ(vvv1227), vvv123100, vvv1228, Succ(vvv1227))
new_primQuotInt33(vvv1265, Succ(vvv12660), Zero, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, Pos(Zero))
Used ordering: Polynomial interpretation [25]:

POL(Neg(x1)) = 1   
POL(Pos(x1)) = 0   
POL(Succ(x1)) = 0   
POL(Zero) = 0   
POL(new_primMinusNatS2(x1, x2)) = 0   
POL(new_primQuotInt17(x1, x2, x3, x4, x5)) = 0   
POL(new_primQuotInt20(x1, x2, x3, x4, x5, x6)) = x3   
POL(new_primQuotInt21(x1, x2, x3, x4, x5)) = x4 + x5   
POL(new_primQuotInt22(x1, x2)) = 0   
POL(new_primQuotInt23(x1, x2)) = x2   
POL(new_primQuotInt25(x1, x2, x3)) = x2   
POL(new_primQuotInt26(x1, x2, x3, x4)) = x2 + x3   
POL(new_primQuotInt27(x1, x2, x3, x4)) = x3   
POL(new_primQuotInt28(x1, x2, x3)) = x2 + x3   
POL(new_primQuotInt29(x1, x2, x3, x4)) = x2   
POL(new_primQuotInt30(x1, x2, x3, x4, x5)) = x4   
POL(new_primQuotInt31(x1, x2, x3, x4, x5, x6)) = x3 + x6   
POL(new_primQuotInt32(x1, x2, x3, x4)) = 0   
POL(new_primQuotInt33(x1, x2, x3, x4, x5)) = x4 + x5   
POL(new_primQuotInt34(x1, x2)) = 1   
POL(new_primQuotInt37(x1, x2, x3)) = 1 + x2   
POL(new_primQuotInt38(x1, x2, x3, x4)) = x4   
POL(new_primQuotInt39(x1, x2, x3, x4)) = 0   
POL(new_primQuotInt40(x1, x2, x3)) = 0   

The following usable rules [17] were oriented: none



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ QDPOrderProof
QDP
                                                                                                                          ↳ DependencyGraphProof
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt32(z0, z1, z2, Pos(Zero)) → new_primQuotInt39(z0, z1, z2, Pos(Zero))
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Neg(Zero), vvv1047) → new_primQuotInt34(vvv1028, vvv10300)
new_primQuotInt29(z0, z1, z2, Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt32(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt39(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Pos(vvv10330), vvv1047) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt33(vvv1265, Succ(vvv12660), Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt33(vvv1265, vvv12660, vvv12670, vvv1268, vvv1269)
new_primQuotInt32(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt39(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Neg(Zero)) → new_primQuotInt37(vvv1186, vvv1188, vvv1187)
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt39(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt33(vvv1265, Zero, Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt40(vvv1265, vvv1268, vvv1269)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Neg(vvv10250), vvv1038) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt21(vvv1020, Zero, vvv102500, Succ(vvv10220), Zero)
new_primQuotInt40(vvv1265, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, Pos(Zero))
new_primQuotInt26(z0, z1, Zero, Pos(Zero)) → new_primQuotInt29(z0, z1, Zero, Pos(Zero))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, Pos(Zero))
new_primQuotInt21(vvv1300, Zero, Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt28(vvv1300, vvv1303, vvv1304)
new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)
new_primQuotInt26(z0, z1, z2, Pos(Zero)) → new_primQuotInt29(z0, z1, z2, Pos(Zero))
new_primQuotInt39(z0, z1, z2, Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Neg(vvv12310)) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt33(vvv1265, Succ(vvv12660), Zero, vvv1268, vvv1269) → new_primQuotInt32(vvv1265, vvv1268, vvv1269, Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Succ(vvv123100))) → new_primQuotInt21(vvv1226, Succ(vvv1227), vvv123100, vvv1228, Succ(vvv1227))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 2 SCCs with 5 less nodes.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ QDPOrderProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ DependencyGraphProof
                                                                                                                            ↳ AND
QDP
                                                                                                                                ↳ Instantiation
                                                                                                                              ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt32(z0, z1, z2, Pos(Zero)) → new_primQuotInt39(z0, z1, z2, Pos(Zero))
new_primQuotInt29(z0, z1, z2, Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Pos(vvv10330), vvv1047) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))
new_primQuotInt32(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt39(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt32(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt39(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt39(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Neg(vvv10250), vvv1038) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt21(vvv1020, Zero, vvv102500, Succ(vvv10220), Zero)
new_primQuotInt26(z0, z1, Zero, Pos(Zero)) → new_primQuotInt29(z0, z1, Zero, Pos(Zero))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, Pos(Zero))
new_primQuotInt21(vvv1300, Zero, Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt28(vvv1300, vvv1303, vvv1304)
new_primQuotInt26(z0, z1, z2, Pos(Zero)) → new_primQuotInt29(z0, z1, z2, Pos(Zero))
new_primQuotInt39(z0, z1, z2, Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Neg(vvv12310)) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Succ(vvv123100))) → new_primQuotInt21(vvv1226, Succ(vvv1227), vvv123100, vvv1228, Succ(vvv1227))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt32(z0, z1, z2, Pos(Zero)) → new_primQuotInt39(z0, z1, z2, Pos(Zero)) we obtained the following new rules:

new_primQuotInt32(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt39(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt32(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt39(z0, Succ(z1), Zero, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ QDPOrderProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ DependencyGraphProof
                                                                                                                            ↳ AND
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                              ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt29(z0, z1, z2, Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt32(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt39(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Pos(vvv10330), vvv1047) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt32(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt39(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt39(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Neg(vvv10250), vvv1038) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt21(vvv1020, Zero, vvv102500, Succ(vvv10220), Zero)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt26(z0, z1, Zero, Pos(Zero)) → new_primQuotInt29(z0, z1, Zero, Pos(Zero))
new_primQuotInt21(vvv1300, Zero, Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt28(vvv1300, vvv1303, vvv1304)
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, Pos(Zero))
new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)
new_primQuotInt26(z0, z1, z2, Pos(Zero)) → new_primQuotInt29(z0, z1, z2, Pos(Zero))
new_primQuotInt39(z0, z1, z2, Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Neg(vvv12310)) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Succ(vvv123100))) → new_primQuotInt21(vvv1226, Succ(vvv1227), vvv123100, vvv1228, Succ(vvv1227))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt39(z0, z1, z2, Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), z2, Pos(Zero), Succ(z1)) we obtained the following new rules:

new_primQuotInt39(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt17(z0, Succ(Succ(z1)), Zero, Pos(Zero), Succ(Succ(z1)))
new_primQuotInt39(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ QDPOrderProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ DependencyGraphProof
                                                                                                                            ↳ AND
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
QDP
                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt29(z0, z1, z2, Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt30(vvv1028, Succ(Zero), Succ(vvv10300), Pos(vvv10330), vvv1047) → new_primQuotInt32(vvv1028, Succ(vvv10300), Zero, Pos(Zero))
new_primQuotInt32(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt39(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt39(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt17(z0, Succ(Succ(z1)), Zero, Pos(Zero), Succ(Succ(z1)))
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt32(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt39(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt39(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Neg(vvv10250), vvv1038) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt21(vvv1020, Zero, vvv102500, Succ(vvv10220), Zero)
new_primQuotInt26(z0, z1, Zero, Pos(Zero)) → new_primQuotInt29(z0, z1, Zero, Pos(Zero))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, Pos(Zero))
new_primQuotInt21(vvv1300, Zero, Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt28(vvv1300, vvv1303, vvv1304)
new_primQuotInt26(z0, z1, z2, Pos(Zero)) → new_primQuotInt29(z0, z1, z2, Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Neg(vvv12310)) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Succ(vvv123100))) → new_primQuotInt21(vvv1226, Succ(vvv1227), vvv123100, vvv1228, Succ(vvv1227))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 3 less nodes.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ QDPOrderProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ DependencyGraphProof
                                                                                                                            ↳ AND
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ DependencyGraphProof
QDP
                                                                                                                                            ↳ QDPOrderProof
                                                                                                                              ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt29(z0, z1, z2, Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt32(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt39(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt39(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Neg(vvv10250), vvv1038) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt21(vvv1020, Zero, vvv102500, Succ(vvv10220), Zero)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt26(z0, z1, Zero, Pos(Zero)) → new_primQuotInt29(z0, z1, Zero, Pos(Zero))
new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, Pos(Zero))
new_primQuotInt21(vvv1300, Zero, Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt28(vvv1300, vvv1303, vvv1304)
new_primQuotInt26(z0, z1, z2, Pos(Zero)) → new_primQuotInt29(z0, z1, z2, Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Neg(vvv12310)) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Succ(vvv123100))) → new_primQuotInt21(vvv1226, Succ(vvv1227), vvv123100, vvv1228, Succ(vvv1227))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Neg(vvv10250), vvv1038) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Neg(vvv12310)) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
The remaining pairs can at least be oriented weakly.

new_primQuotInt29(z0, z1, z2, Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt32(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt39(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt39(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt21(vvv1020, Zero, vvv102500, Succ(vvv10220), Zero)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt26(z0, z1, Zero, Pos(Zero)) → new_primQuotInt29(z0, z1, Zero, Pos(Zero))
new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, Pos(Zero))
new_primQuotInt21(vvv1300, Zero, Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt28(vvv1300, vvv1303, vvv1304)
new_primQuotInt26(z0, z1, z2, Pos(Zero)) → new_primQuotInt29(z0, z1, z2, Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Succ(vvv123100))) → new_primQuotInt21(vvv1226, Succ(vvv1227), vvv123100, vvv1228, Succ(vvv1227))
Used ordering: Polynomial interpretation [25]:

POL(Neg(x1)) = 1   
POL(Pos(x1)) = 0   
POL(Succ(x1)) = 0   
POL(Zero) = 0   
POL(new_primMinusNatS2(x1, x2)) = 0   
POL(new_primQuotInt17(x1, x2, x3, x4, x5)) = x3 + x4   
POL(new_primQuotInt20(x1, x2, x3, x4, x5, x6)) = x3 + x6   
POL(new_primQuotInt21(x1, x2, x3, x4, x5)) = x5   
POL(new_primQuotInt22(x1, x2)) = 0   
POL(new_primQuotInt23(x1, x2)) = x2   
POL(new_primQuotInt25(x1, x2, x3)) = 0   
POL(new_primQuotInt26(x1, x2, x3, x4)) = x3   
POL(new_primQuotInt27(x1, x2, x3, x4)) = x3 + x4   
POL(new_primQuotInt28(x1, x2, x3)) = x3   
POL(new_primQuotInt29(x1, x2, x3, x4)) = x3   
POL(new_primQuotInt30(x1, x2, x3, x4, x5)) = 0   
POL(new_primQuotInt31(x1, x2, x3, x4, x5, x6)) = 0   
POL(new_primQuotInt32(x1, x2, x3, x4)) = 0   
POL(new_primQuotInt38(x1, x2, x3, x4)) = 0   
POL(new_primQuotInt39(x1, x2, x3, x4)) = 0   

The following usable rules [17] were oriented: none



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ QDPOrderProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ DependencyGraphProof
                                                                                                                            ↳ AND
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ QDPOrderProof
QDP
                                                                                                                                                ↳ QDPOrderProof
                                                                                                                              ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt29(z0, z1, z2, Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt32(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt39(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt39(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt21(vvv1020, Zero, vvv102500, Succ(vvv10220), Zero)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt26(z0, z1, Zero, Pos(Zero)) → new_primQuotInt29(z0, z1, Zero, Pos(Zero))
new_primQuotInt21(vvv1300, Zero, Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt28(vvv1300, vvv1303, vvv1304)
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, Pos(Zero))
new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)
new_primQuotInt26(z0, z1, z2, Pos(Zero)) → new_primQuotInt29(z0, z1, z2, Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Succ(vvv123100))) → new_primQuotInt21(vvv1226, Succ(vvv1227), vvv123100, vvv1228, Succ(vvv1227))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Succ(vvv102500)), vvv1038) → new_primQuotInt21(vvv1020, Zero, vvv102500, Succ(vvv10220), Zero)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Succ(vvv123100))) → new_primQuotInt21(vvv1226, Succ(vvv1227), vvv123100, vvv1228, Succ(vvv1227))
The remaining pairs can at least be oriented weakly.

new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt29(z0, z1, z2, Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt32(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt39(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt39(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt26(z0, z1, Zero, Pos(Zero)) → new_primQuotInt29(z0, z1, Zero, Pos(Zero))
new_primQuotInt21(vvv1300, Zero, Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt28(vvv1300, vvv1303, vvv1304)
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, Pos(Zero))
new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)
new_primQuotInt26(z0, z1, z2, Pos(Zero)) → new_primQuotInt29(z0, z1, z2, Pos(Zero))
Used ordering: Polynomial interpretation [25]:

POL(Pos(x1)) = x1   
POL(Succ(x1)) = 1   
POL(Zero) = 0   
POL(new_primMinusNatS2(x1, x2)) = 0   
POL(new_primQuotInt17(x1, x2, x3, x4, x5)) = x4   
POL(new_primQuotInt20(x1, x2, x3, x4, x5, x6)) = x6   
POL(new_primQuotInt21(x1, x2, x3, x4, x5)) = 0   
POL(new_primQuotInt22(x1, x2)) = 0   
POL(new_primQuotInt23(x1, x2)) = 0   
POL(new_primQuotInt25(x1, x2, x3)) = 0   
POL(new_primQuotInt26(x1, x2, x3, x4)) = 0   
POL(new_primQuotInt27(x1, x2, x3, x4)) = x4   
POL(new_primQuotInt28(x1, x2, x3)) = 0   
POL(new_primQuotInt29(x1, x2, x3, x4)) = 0   
POL(new_primQuotInt30(x1, x2, x3, x4, x5)) = 0   
POL(new_primQuotInt31(x1, x2, x3, x4, x5, x6)) = 0   
POL(new_primQuotInt32(x1, x2, x3, x4)) = 0   
POL(new_primQuotInt38(x1, x2, x3, x4)) = 0   
POL(new_primQuotInt39(x1, x2, x3, x4)) = 0   

The following usable rules [17] were oriented: none



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ QDPOrderProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ DependencyGraphProof
                                                                                                                            ↳ AND
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ QDPOrderProof
QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt29(z0, z1, z2, Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt28(vvv1300, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt32(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt39(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt39(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt21(vvv1300, Succ(vvv13010), Zero, vvv1303, vvv1304) → new_primQuotInt26(vvv1300, vvv1303, vvv1304, Pos(Zero))
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt26(z0, z1, Zero, Pos(Zero)) → new_primQuotInt29(z0, z1, Zero, Pos(Zero))
new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)
new_primQuotInt21(vvv1300, Zero, Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt28(vvv1300, vvv1303, vvv1304)
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, Pos(Zero))
new_primQuotInt26(z0, z1, z2, Pos(Zero)) → new_primQuotInt29(z0, z1, z2, Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 2 SCCs with 3 less nodes.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ QDPOrderProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ DependencyGraphProof
                                                                                                                            ↳ AND
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ QDPOrderProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ AND
QDP
                                                                                                                                                          ↳ Instantiation
                                                                                                                                                        ↳ QDP
                                                                                                                              ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt29(z0, z1, z2, Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt32(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt39(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt39(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt26(z0, z1, Zero, Pos(Zero)) → new_primQuotInt29(z0, z1, Zero, Pos(Zero))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt26(z0, z1, z2, Pos(Zero)) → new_primQuotInt29(z0, z1, z2, Pos(Zero))
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt26(z0, z1, z2, Pos(Zero)) → new_primQuotInt29(z0, z1, z2, Pos(Zero)) we obtained the following new rules:

new_primQuotInt26(z0, z1, Zero, Pos(Zero)) → new_primQuotInt29(z0, z1, Zero, Pos(Zero))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ QDPOrderProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ DependencyGraphProof
                                                                                                                            ↳ AND
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ QDPOrderProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ AND
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Instantiation
QDP
                                                                                                                                                              ↳ Instantiation
                                                                                                                                                        ↳ QDP
                                                                                                                              ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt32(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt39(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt29(z0, z1, z2, Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt39(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt26(z0, z1, Zero, Pos(Zero)) → new_primQuotInt29(z0, z1, Zero, Pos(Zero))
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt29(z0, z1, z2, Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), z2, Pos(Zero), Succ(z1)) we obtained the following new rules:

new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt29(z0, z1, Zero, Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Zero, Pos(Zero), Succ(z1))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ QDPOrderProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ DependencyGraphProof
                                                                                                                            ↳ AND
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ QDPOrderProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ AND
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Instantiation
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ Instantiation
QDP
                                                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                              ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt32(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt39(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt39(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt17(vvv1020, Succ(Zero), Succ(vvv10220), Pos(Zero), vvv1038) → new_primQuotInt22(vvv1020, vvv10220)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt26(z0, z1, Zero, Pos(Zero)) → new_primQuotInt29(z0, z1, Zero, Pos(Zero))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt29(z0, z1, Zero, Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Zero, Pos(Zero), Succ(z1))
new_primQuotInt22(vvv1020, vvv10220) → new_primQuotInt23(vvv1020, Succ(vvv10220))
new_primQuotInt23(vvv1060, vvv1061) → new_primQuotInt26(vvv1060, vvv1061, Zero, Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 5 less nodes.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ QDPOrderProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ DependencyGraphProof
                                                                                                                            ↳ AND
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ QDPOrderProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ AND
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Instantiation
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ DependencyGraphProof
QDP
                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                        ↳ QDP
                                                                                                                              ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt32(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt39(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt39(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Zero, vvv1191) → new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Zero, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
The remaining pairs can at least be oriented weakly.

new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt32(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt39(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt39(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
Used ordering: Matrix interpretation [3]:
Non-tuple symbols:
M( Succ(x1) ) =
/0\
\1/
+
/11\
\00/
·x1

M( new_primMinusNatS2(x1, x2) ) =
/0\
\1/
+
/10\
\11/
·x1+
/00\
\00/
·x2

M( Zero ) =
/0\
\1/

M( Pos(x1) ) =
/1\
\1/
+
/00\
\01/
·x1

Tuple symbols:
M( new_primQuotInt20(x1, ..., x6) ) = 0+
[0,0]
·x1+
[0,0]
·x2+
[1,1]
·x3+
[0,0]
·x4+
[0,0]
·x5+
[1,0]
·x6

M( new_primQuotInt29(x1, ..., x4) ) = 1+
[0,0]
·x1+
[1,1]
·x2+
[0,0]
·x3+
[0,0]
·x4

M( new_primQuotInt32(x1, ..., x4) ) = 1+
[0,0]
·x1+
[0,0]
·x2+
[1,1]
·x3+
[0,0]
·x4

M( new_primQuotInt26(x1, ..., x4) ) = 1+
[0,0]
·x1+
[1,1]
·x2+
[0,0]
·x3+
[0,0]
·x4

M( new_primQuotInt39(x1, ..., x4) ) = 0+
[0,0]
·x1+
[0,0]
·x2+
[1,0]
·x3+
[0,1]
·x4

M( new_primQuotInt31(x1, ..., x6) ) = 1+
[0,0]
·x1+
[1,1]
·x2+
[0,0]
·x3+
[0,0]
·x4+
[0,0]
·x5+
[1,0]
·x6

M( new_primQuotInt17(x1, ..., x5) ) = 0+
[0,0]
·x1+
[0,0]
·x2+
[1,1]
·x3+
[1,0]
·x4+
[0,0]
·x5

M( new_primQuotInt30(x1, ..., x5) ) = 0+
[0,0]
·x1+
[1,0]
·x2+
[0,0]
·x3+
[1,0]
·x4+
[0,0]
·x5

M( new_primQuotInt25(x1, ..., x3) ) = 1+
[0,0]
·x1+
[1,1]
·x2+
[0,0]
·x3

M( new_primQuotInt27(x1, ..., x4) ) = 0+
[0,0]
·x1+
[0,0]
·x2+
[1,1]
·x3+
[1,0]
·x4

M( new_primQuotInt38(x1, ..., x4) ) = 0+
[0,0]
·x1+
[1,1]
·x2+
[0,0]
·x3+
[1,0]
·x4


Matrix type:
We used a basic matrix type which is not further parametrizeable.


As matrix orders are CE-compatible, we used usable rules w.r.t. argument filtering in the order.
The following usable rules [17] were oriented:

new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Zero, Zero) → Zero



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ QDPOrderProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ DependencyGraphProof
                                                                                                                            ↳ AND
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ QDPOrderProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ AND
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Instantiation
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ QDPOrderProof
QDP
                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                              ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt32(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt39(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt39(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt38(vvv1186, vvv1187, vvv1188, vvv1191) → new_primQuotInt30(vvv1186, new_primMinusNatS2(Succ(vvv1187), vvv1188), vvv1188, vvv1191, new_primMinusNatS2(Succ(vvv1187), vvv1188))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ QDPOrderProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ DependencyGraphProof
                                                                                                                            ↳ AND
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ QDPOrderProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ AND
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Instantiation
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ DependencyGraphProof
QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                        ↳ QDP
                                                                                                                              ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt32(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt39(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033)
new_primQuotInt39(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt30(vvv1028, Succ(Succ(vvv104800)), Succ(vvv10300), vvv1033, vvv1047) → new_primQuotInt31(vvv1028, vvv104800, Succ(vvv10300), vvv104800, vvv10300, vvv1033) we obtained the following new rules:

new_primQuotInt30(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt31(z0, x1, Succ(z2), x1, z2, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ QDPOrderProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ DependencyGraphProof
                                                                                                                            ↳ AND
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ QDPOrderProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ AND
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Instantiation
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
QDP
                                                                                                                                                                                  ↳ QDPOrderProof
                                                                                                                                                        ↳ QDP
                                                                                                                              ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt32(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt39(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt39(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt30(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt31(z0, x1, Succ(z2), x1, z2, Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Zero, vvv1231) → new_primQuotInt17(vvv1226, new_primMinusNatS2(Succ(vvv1227), vvv1228), vvv1228, vvv1231, new_primMinusNatS2(Succ(vvv1227), vvv1228))
The remaining pairs can at least be oriented weakly.

new_primQuotInt32(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt39(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt39(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt30(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt31(z0, x1, Succ(z2), x1, z2, Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
Used ordering: Matrix interpretation [3]:
Non-tuple symbols:
M( Succ(x1) ) =
/0\
\1/
+
/11\
\00/
·x1

M( new_primMinusNatS2(x1, x2) ) =
/0\
\0/
+
/10\
\00/
·x1+
/00\
\10/
·x2

M( Zero ) =
/1\
\0/

M( Pos(x1) ) =
/1\
\0/
+
/00\
\00/
·x1

Tuple symbols:
M( new_primQuotInt20(x1, ..., x6) ) = 1+
[0,0]
·x1+
[1,1]
·x2+
[0,0]
·x3+
[0,0]
·x4+
[0,0]
·x5+
[0,0]
·x6

M( new_primQuotInt32(x1, ..., x4) ) = 0+
[0,0]
·x1+
[1,1]
·x2+
[0,0]
·x3+
[0,0]
·x4

M( new_primQuotInt29(x1, ..., x4) ) = 1+
[0,0]
·x1+
[0,0]
·x2+
[1,0]
·x3+
[0,0]
·x4

M( new_primQuotInt26(x1, ..., x4) ) = 0+
[0,0]
·x1+
[0,0]
·x2+
[1,0]
·x3+
[1,0]
·x4

M( new_primQuotInt39(x1, ..., x4) ) = 0+
[0,0]
·x1+
[1,1]
·x2+
[0,0]
·x3+
[0,0]
·x4

M( new_primQuotInt31(x1, ..., x6) ) = 0+
[0,0]
·x1+
[0,0]
·x2+
[1,1]
·x3+
[0,0]
·x4+
[0,0]
·x5+
[0,0]
·x6

M( new_primQuotInt17(x1, ..., x5) ) = 0+
[0,0]
·x1+
[1,0]
·x2+
[0,0]
·x3+
[0,0]
·x4+
[0,0]
·x5

M( new_primQuotInt30(x1, ..., x5) ) = 0+
[0,0]
·x1+
[0,0]
·x2+
[1,0]
·x3+
[1,0]
·x4+
[0,0]
·x5

M( new_primQuotInt25(x1, ..., x3) ) = 1+
[0,0]
·x1+
[0,0]
·x2+
[1,1]
·x3

M( new_primQuotInt27(x1, ..., x4) ) = 1+
[0,0]
·x1+
[1,1]
·x2+
[0,0]
·x3+
[0,0]
·x4


Matrix type:
We used a basic matrix type which is not further parametrizeable.


As matrix orders are CE-compatible, we used usable rules w.r.t. argument filtering in the order.
The following usable rules [17] were oriented:

new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Zero, Zero) → Zero



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ QDPOrderProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ DependencyGraphProof
                                                                                                                            ↳ AND
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ QDPOrderProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ AND
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Instantiation
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ QDPOrderProof
QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                              ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt30(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt31(z0, x1, Succ(z2), x1, z2, Pos(Zero))
new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt32(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt39(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt39(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Zero, vvv1231) → new_primQuotInt27(vvv1226, vvv1227, vvv1228, vvv1231)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ QDPOrderProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ DependencyGraphProof
                                                                                                                            ↳ AND
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ QDPOrderProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ AND
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Instantiation
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ QDPOrderProof
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
QDP
                                                                                                                                                                                          ↳ UsableRulesProof
                                                                                                                                                        ↳ QDP
                                                                                                                              ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt32(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt39(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt30(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt31(z0, x1, Succ(z2), x1, z2, Pos(Zero))
new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt39(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ QDPOrderProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ DependencyGraphProof
                                                                                                                            ↳ AND
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ QDPOrderProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ AND
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Instantiation
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ QDPOrderProof
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ UsableRulesProof
QDP
                                                                                                                                                                                              ↳ QReductionProof
                                                                                                                                                        ↳ QDP
                                                                                                                              ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt32(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt39(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt30(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt31(z0, x1, Succ(z2), x1, z2, Pos(Zero))
new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt39(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))

R is empty.
The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ QDPOrderProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ DependencyGraphProof
                                                                                                                            ↳ AND
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ QDPOrderProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ AND
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Instantiation
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ QDPOrderProof
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ UsableRulesProof
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ QReductionProof
QDP
                                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                        ↳ QDP
                                                                                                                              ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt30(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt31(z0, x1, Succ(z2), x1, z2, Pos(Zero))
new_primQuotInt32(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt39(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt39(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025)
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt17(vvv1020, Succ(Succ(vvv103900)), Succ(vvv10220), vvv1025, vvv1038) → new_primQuotInt20(vvv1020, vvv103900, Succ(vvv10220), vvv103900, vvv10220, vvv1025) we obtained the following new rules:

new_primQuotInt17(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt20(z0, x1, Succ(z2), x1, z2, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ QDPOrderProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ DependencyGraphProof
                                                                                                                            ↳ AND
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ QDPOrderProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ AND
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Instantiation
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ QDPOrderProof
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ UsableRulesProof
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ QReductionProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Instantiation
QDP
                                                                                                                                                                                                      ↳ NonInfProof
                                                                                                                                                        ↳ QDP
                                                                                                                              ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt32(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt39(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt30(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt31(z0, x1, Succ(z2), x1, z2, Pos(Zero))
new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt39(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt17(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt20(z0, x1, Succ(z2), x1, z2, Pos(Zero))
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The DP Problem is simplified using the Induction Calculus [18] with the following steps:
Note that final constraints are written in bold face.


For Pair new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191) the following chains were created:




For Pair new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231) the following chains were created:




For Pair new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero)) the following chains were created:




For Pair new_primQuotInt32(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt39(z0, z2, Succ(z1), Pos(Zero)) the following chains were created:




For Pair new_primQuotInt30(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt31(z0, x1, Succ(z2), x1, z2, Pos(Zero)) the following chains were created:




For Pair new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1)) the following chains were created:




For Pair new_primQuotInt39(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1)) the following chains were created:




For Pair new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227) the following chains were created:




For Pair new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero)) the following chains were created:




For Pair new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) the following chains were created:




For Pair new_primQuotInt17(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt20(z0, x1, Succ(z2), x1, z2, Pos(Zero)) the following chains were created:




To summarize, we get the following constraints P for the following pairs.



The constraints for P> respective Pbound are constructed from P where we just replace every occurence of "t ≥ s" in P by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for Pbound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation [18]:

POL(Pos(x1)) = 0   
POL(Succ(x1)) = 1 + x1   
POL(Zero) = 0   
POL(c) = -2   
POL(new_primQuotInt17(x1, x2, x3, x4, x5)) = x1 - x2 + x3 + x4   
POL(new_primQuotInt20(x1, x2, x3, x4, x5, x6)) = -1 + x1 - x4 + x5 - x6   
POL(new_primQuotInt25(x1, x2, x3)) = -1 + x1   
POL(new_primQuotInt26(x1, x2, x3, x4)) = -1 + x1 + x4   
POL(new_primQuotInt29(x1, x2, x3, x4)) = -1 + x1 - x4   
POL(new_primQuotInt30(x1, x2, x3, x4, x5)) = -1 + x1 - x2 + x4 + x5   
POL(new_primQuotInt31(x1, x2, x3, x4, x5, x6)) = -1 + x1 + x2 - x3 - x4 + x5 - x6   
POL(new_primQuotInt32(x1, x2, x3, x4)) = -1 + x1 - x2 + x3 + x4   
POL(new_primQuotInt39(x1, x2, x3, x4)) = -1 + x1 - x2 + x3 + x4   

The following pairs are in P>:

new_primQuotInt30(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt31(z0, x1, Succ(z2), x1, z2, Pos(Zero))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
The following pairs are in Pbound:

new_primQuotInt30(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt31(z0, x1, Succ(z2), x1, z2, Pos(Zero))
new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt20(vvv1226, vvv1227, vvv1228, Zero, Succ(vvv12300), Pos(Zero)) → new_primQuotInt25(vvv1226, vvv1228, vvv1227)
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))
There are no usable rules

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ QDPOrderProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ DependencyGraphProof
                                                                                                                            ↳ AND
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ QDPOrderProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ AND
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Instantiation
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ QDPOrderProof
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ UsableRulesProof
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ QReductionProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ NonInfProof
QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                              ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)
new_primQuotInt31(vvv1186, vvv1187, vvv1188, Zero, Succ(vvv11900), Pos(vvv11910)) → new_primQuotInt32(vvv1186, vvv1188, Succ(vvv1187), Pos(Zero))
new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt30(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt32(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt39(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt39(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt17(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt17(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt20(z0, x1, Succ(z2), x1, z2, Pos(Zero))
new_primQuotInt25(vvv1226, vvv1228, vvv1227) → new_primQuotInt26(vvv1226, vvv1228, Succ(vvv1227), Pos(Zero))
new_primQuotInt26(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt29(z0, z1, Succ(z2), Pos(Zero))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 2 SCCs with 7 less nodes.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ QDPOrderProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ DependencyGraphProof
                                                                                                                            ↳ AND
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ QDPOrderProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ AND
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Instantiation
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ QDPOrderProof
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ UsableRulesProof
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ QReductionProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ NonInfProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
QDP
                                                                                                                                                                                                                ↳ QDPSizeChangeProof
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                        ↳ QDP
                                                                                                                              ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt20(vvv1226, vvv1227, vvv1228, Succ(vvv12290), Succ(vvv12300), vvv1231) → new_primQuotInt20(vvv1226, vvv1227, vvv1228, vvv12290, vvv12300, vvv1231)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ QDPOrderProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ DependencyGraphProof
                                                                                                                            ↳ AND
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ QDPOrderProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ AND
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Instantiation
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ QDPOrderProof
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ UsableRulesProof
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ QReductionProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ NonInfProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
QDP
                                                                                                                                                                                                                ↳ QDPSizeChangeProof
                                                                                                                                                        ↳ QDP
                                                                                                                              ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt31(vvv1186, vvv1187, vvv1188, Succ(vvv11890), Succ(vvv11900), vvv1191) → new_primQuotInt31(vvv1186, vvv1187, vvv1188, vvv11890, vvv11900, vvv1191)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ QDPOrderProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ DependencyGraphProof
                                                                                                                            ↳ AND
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ QDPOrderProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ AND
                                                                                                                                                        ↳ QDP
QDP
                                                                                                                                                          ↳ UsableRulesProof
                                                                                                                              ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ QDPOrderProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ DependencyGraphProof
                                                                                                                            ↳ AND
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ QDPOrderProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ AND
                                                                                                                                                        ↳ QDP
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ UsableRulesProof
QDP
                                                                                                                                                              ↳ QReductionProof
                                                                                                                              ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)

R is empty.
The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ QDPOrderProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ DependencyGraphProof
                                                                                                                            ↳ AND
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ QDPOrderProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ AND
                                                                                                                                                        ↳ QDP
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ UsableRulesProof
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ QReductionProof
QDP
                                                                                                                                                                  ↳ QDPSizeChangeProof
                                                                                                                              ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt21(vvv1300, Succ(vvv13010), Succ(vvv13020), vvv1303, vvv1304) → new_primQuotInt21(vvv1300, vvv13010, vvv13020, vvv1303, vvv1304)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ QDPOrderProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ DependencyGraphProof
                                                                                                                            ↳ AND
                                                                                                                              ↳ QDP
QDP
                                                                                                                                ↳ UsableRulesProof
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt33(vvv1265, Succ(vvv12660), Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt33(vvv1265, vvv12660, vvv12670, vvv1268, vvv1269)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ QDPOrderProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ DependencyGraphProof
                                                                                                                            ↳ AND
                                                                                                                              ↳ QDP
                                                                                                                              ↳ QDP
                                                                                                                                ↳ UsableRulesProof
QDP
                                                                                                                                    ↳ QReductionProof
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt33(vvv1265, Succ(vvv12660), Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt33(vvv1265, vvv12660, vvv12670, vvv1268, vvv1269)

R is empty.
The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ UsableRulesProof
                                                                                        ↳ QDP
                                                                                          ↳ QReductionProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ QDPOrderProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ DependencyGraphProof
                                                                                                                            ↳ AND
                                                                                                                              ↳ QDP
                                                                                                                              ↳ QDP
                                                                                                                                ↳ UsableRulesProof
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ QReductionProof
QDP
                                                                                                                                        ↳ QDPSizeChangeProof
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt33(vvv1265, Succ(vvv12660), Succ(vvv12670), vvv1268, vvv1269) → new_primQuotInt33(vvv1265, vvv12660, vvv12670, vvv1268, vvv1269)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
QDP
                                  ↳ UsableRulesProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Zero, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt49(vvv1285, Zero, Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt55(vvv1285, vvv1288, vvv1289)
new_primQuotInt48(vvv1285, vvv1288, vvv1289, vvv1307) → new_primQuotInt54(vvv1285, vvv1288, vvv1289, vvv1307)
new_primQuotInt54(vvv802, vvv803, vvv806, vvv807) → new_primQuotInt45(vvv802, Succ(vvv803), vvv806, vvv807, Succ(vvv803))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Zero, vvv1217) → new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217)
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Pos(vvv10730), vvv1083) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, new_fromInt)
new_primQuotInt52(vvv1212, vvv1214, vvv1213) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), new_fromInt)
new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt55(vvv1285, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, new_fromInt)
new_primQuotInt45(vvv1068, Succ(Succ(vvv108400)), Succ(vvv10700), vvv1073, vvv1083) → new_primQuotInt47(vvv1068, vvv108400, Succ(vvv10700), vvv108400, vvv10700, vvv1073)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Pos(vvv12170)) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), new_fromInt)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Neg(Zero)) → new_primQuotInt52(vvv1212, vvv1214, vvv1213)
new_primQuotInt49(vvv1285, Succ(vvv12860), Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt49(vvv1285, vvv12860, vvv12870, vvv1288, vvv1289)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Succ(vvv12160), vvv1217) → new_primQuotInt47(vvv1212, vvv1213, vvv1214, vvv12150, vvv12160, vvv1217)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Neg(Succ(vvv121700))) → new_primQuotInt49(vvv1212, Succ(vvv1213), vvv121700, vvv1214, Succ(vvv1213))
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Neg(Succ(vvv107300)), vvv1083) → new_primQuotInt49(vvv1068, Zero, vvv107300, Succ(vvv10700), Zero)
new_primQuotInt49(vvv1285, Succ(vvv12860), Zero, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, new_fromInt)
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Neg(Zero), vvv1083) → new_primQuotInt50(vvv1068, vvv10700)
new_primQuotInt50(vvv1068, vvv10700) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, new_fromInt)

The TRS R consists of the following rules:

new_primRemInt3(vvv46800) → new_error
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_rem1(vvv1030) → new_primRemInt4(vvv1030)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_errorerror([])
new_rem(vvv1160) → new_primRemInt5(vvv1160)
new_rem0(vvv1008) → new_primRemInt3(vvv1008)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Zero) → Zero
new_rem2(vvv47200) → new_primRemInt6(vvv47200)
new_primRemInt6(vvv47200) → new_error
new_fromIntPos(Zero)
new_primRemInt5(vvv2200) → new_error
new_primRemInt4(vvv2200) → new_error

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
QDP
                                      ↳ QReductionProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Zero, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt49(vvv1285, Zero, Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt55(vvv1285, vvv1288, vvv1289)
new_primQuotInt48(vvv1285, vvv1288, vvv1289, vvv1307) → new_primQuotInt54(vvv1285, vvv1288, vvv1289, vvv1307)
new_primQuotInt54(vvv802, vvv803, vvv806, vvv807) → new_primQuotInt45(vvv802, Succ(vvv803), vvv806, vvv807, Succ(vvv803))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Zero, vvv1217) → new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217)
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Pos(vvv10730), vvv1083) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, new_fromInt)
new_primQuotInt52(vvv1212, vvv1214, vvv1213) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), new_fromInt)
new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt55(vvv1285, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, new_fromInt)
new_primQuotInt45(vvv1068, Succ(Succ(vvv108400)), Succ(vvv10700), vvv1073, vvv1083) → new_primQuotInt47(vvv1068, vvv108400, Succ(vvv10700), vvv108400, vvv10700, vvv1073)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Pos(vvv12170)) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), new_fromInt)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Neg(Zero)) → new_primQuotInt52(vvv1212, vvv1214, vvv1213)
new_primQuotInt49(vvv1285, Succ(vvv12860), Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt49(vvv1285, vvv12860, vvv12870, vvv1288, vvv1289)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Succ(vvv12160), vvv1217) → new_primQuotInt47(vvv1212, vvv1213, vvv1214, vvv12150, vvv12160, vvv1217)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Neg(Succ(vvv121700))) → new_primQuotInt49(vvv1212, Succ(vvv1213), vvv121700, vvv1214, Succ(vvv1213))
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Neg(Succ(vvv107300)), vvv1083) → new_primQuotInt49(vvv1068, Zero, vvv107300, Succ(vvv10700), Zero)
new_primQuotInt49(vvv1285, Succ(vvv12860), Zero, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, new_fromInt)
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Neg(Zero), vvv1083) → new_primQuotInt50(vvv1068, vvv10700)
new_primQuotInt50(vvv1068, vvv10700) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, new_fromInt)

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_error
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
QDP
                                          ↳ Rewriting
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Zero, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt49(vvv1285, Zero, Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt55(vvv1285, vvv1288, vvv1289)
new_primQuotInt48(vvv1285, vvv1288, vvv1289, vvv1307) → new_primQuotInt54(vvv1285, vvv1288, vvv1289, vvv1307)
new_primQuotInt54(vvv802, vvv803, vvv806, vvv807) → new_primQuotInt45(vvv802, Succ(vvv803), vvv806, vvv807, Succ(vvv803))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Zero, vvv1217) → new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217)
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Pos(vvv10730), vvv1083) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, new_fromInt)
new_primQuotInt52(vvv1212, vvv1214, vvv1213) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), new_fromInt)
new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt55(vvv1285, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, new_fromInt)
new_primQuotInt45(vvv1068, Succ(Succ(vvv108400)), Succ(vvv10700), vvv1073, vvv1083) → new_primQuotInt47(vvv1068, vvv108400, Succ(vvv10700), vvv108400, vvv10700, vvv1073)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Pos(vvv12170)) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), new_fromInt)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Neg(Zero)) → new_primQuotInt52(vvv1212, vvv1214, vvv1213)
new_primQuotInt49(vvv1285, Succ(vvv12860), Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt49(vvv1285, vvv12860, vvv12870, vvv1288, vvv1289)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Succ(vvv12160), vvv1217) → new_primQuotInt47(vvv1212, vvv1213, vvv1214, vvv12150, vvv12160, vvv1217)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Neg(Succ(vvv121700))) → new_primQuotInt49(vvv1212, Succ(vvv1213), vvv121700, vvv1214, Succ(vvv1213))
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Neg(Succ(vvv107300)), vvv1083) → new_primQuotInt49(vvv1068, Zero, vvv107300, Succ(vvv10700), Zero)
new_primQuotInt49(vvv1285, Succ(vvv12860), Zero, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, new_fromInt)
new_primQuotInt50(vvv1068, vvv10700) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, new_fromInt)
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Neg(Zero), vvv1083) → new_primQuotInt50(vvv1068, vvv10700)

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Pos(vvv10730), vvv1083) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Pos(vvv10730), vvv1083) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
QDP
                                              ↳ Rewriting
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt49(vvv1285, Zero, Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt55(vvv1285, vvv1288, vvv1289)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Zero, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt48(vvv1285, vvv1288, vvv1289, vvv1307) → new_primQuotInt54(vvv1285, vvv1288, vvv1289, vvv1307)
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Pos(vvv10730), vvv1083) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Zero, vvv1217) → new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217)
new_primQuotInt54(vvv802, vvv803, vvv806, vvv807) → new_primQuotInt45(vvv802, Succ(vvv803), vvv806, vvv807, Succ(vvv803))
new_primQuotInt52(vvv1212, vvv1214, vvv1213) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), new_fromInt)
new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt55(vvv1285, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, new_fromInt)
new_primQuotInt45(vvv1068, Succ(Succ(vvv108400)), Succ(vvv10700), vvv1073, vvv1083) → new_primQuotInt47(vvv1068, vvv108400, Succ(vvv10700), vvv108400, vvv10700, vvv1073)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Neg(Zero)) → new_primQuotInt52(vvv1212, vvv1214, vvv1213)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Pos(vvv12170)) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), new_fromInt)
new_primQuotInt49(vvv1285, Succ(vvv12860), Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt49(vvv1285, vvv12860, vvv12870, vvv1288, vvv1289)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Succ(vvv12160), vvv1217) → new_primQuotInt47(vvv1212, vvv1213, vvv1214, vvv12150, vvv12160, vvv1217)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Neg(Succ(vvv121700))) → new_primQuotInt49(vvv1212, Succ(vvv1213), vvv121700, vvv1214, Succ(vvv1213))
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Neg(Succ(vvv107300)), vvv1083) → new_primQuotInt49(vvv1068, Zero, vvv107300, Succ(vvv10700), Zero)
new_primQuotInt49(vvv1285, Succ(vvv12860), Zero, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, new_fromInt)
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Neg(Zero), vvv1083) → new_primQuotInt50(vvv1068, vvv10700)
new_primQuotInt50(vvv1068, vvv10700) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, new_fromInt)

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt52(vvv1212, vvv1214, vvv1213) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt52(vvv1212, vvv1214, vvv1213) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
QDP
                                                  ↳ Rewriting
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt52(vvv1212, vvv1214, vvv1213) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Zero, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt49(vvv1285, Zero, Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt55(vvv1285, vvv1288, vvv1289)
new_primQuotInt48(vvv1285, vvv1288, vvv1289, vvv1307) → new_primQuotInt54(vvv1285, vvv1288, vvv1289, vvv1307)
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Pos(vvv10730), vvv1083) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, Pos(Zero))
new_primQuotInt54(vvv802, vvv803, vvv806, vvv807) → new_primQuotInt45(vvv802, Succ(vvv803), vvv806, vvv807, Succ(vvv803))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Zero, vvv1217) → new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217)
new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt55(vvv1285, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, new_fromInt)
new_primQuotInt45(vvv1068, Succ(Succ(vvv108400)), Succ(vvv10700), vvv1073, vvv1083) → new_primQuotInt47(vvv1068, vvv108400, Succ(vvv10700), vvv108400, vvv10700, vvv1073)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Pos(vvv12170)) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), new_fromInt)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Neg(Zero)) → new_primQuotInt52(vvv1212, vvv1214, vvv1213)
new_primQuotInt49(vvv1285, Succ(vvv12860), Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt49(vvv1285, vvv12860, vvv12870, vvv1288, vvv1289)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Succ(vvv12160), vvv1217) → new_primQuotInt47(vvv1212, vvv1213, vvv1214, vvv12150, vvv12160, vvv1217)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Neg(Succ(vvv121700))) → new_primQuotInt49(vvv1212, Succ(vvv1213), vvv121700, vvv1214, Succ(vvv1213))
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Neg(Succ(vvv107300)), vvv1083) → new_primQuotInt49(vvv1068, Zero, vvv107300, Succ(vvv10700), Zero)
new_primQuotInt49(vvv1285, Succ(vvv12860), Zero, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, new_fromInt)
new_primQuotInt50(vvv1068, vvv10700) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, new_fromInt)
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Neg(Zero), vvv1083) → new_primQuotInt50(vvv1068, vvv10700)

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt55(vvv1285, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt55(vvv1285, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
QDP
                                                      ↳ Rewriting
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt52(vvv1212, vvv1214, vvv1213) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))
new_primQuotInt49(vvv1285, Zero, Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt55(vvv1285, vvv1288, vvv1289)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Zero, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt48(vvv1285, vvv1288, vvv1289, vvv1307) → new_primQuotInt54(vvv1285, vvv1288, vvv1289, vvv1307)
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Pos(vvv10730), vvv1083) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Zero, vvv1217) → new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217)
new_primQuotInt54(vvv802, vvv803, vvv806, vvv807) → new_primQuotInt45(vvv802, Succ(vvv803), vvv806, vvv807, Succ(vvv803))
new_primQuotInt55(vvv1285, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, Pos(Zero))
new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt45(vvv1068, Succ(Succ(vvv108400)), Succ(vvv10700), vvv1073, vvv1083) → new_primQuotInt47(vvv1068, vvv108400, Succ(vvv10700), vvv108400, vvv10700, vvv1073)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Neg(Zero)) → new_primQuotInt52(vvv1212, vvv1214, vvv1213)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Pos(vvv12170)) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), new_fromInt)
new_primQuotInt49(vvv1285, Succ(vvv12860), Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt49(vvv1285, vvv12860, vvv12870, vvv1288, vvv1289)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Succ(vvv12160), vvv1217) → new_primQuotInt47(vvv1212, vvv1213, vvv1214, vvv12150, vvv12160, vvv1217)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Neg(Succ(vvv121700))) → new_primQuotInt49(vvv1212, Succ(vvv1213), vvv121700, vvv1214, Succ(vvv1213))
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Neg(Succ(vvv107300)), vvv1083) → new_primQuotInt49(vvv1068, Zero, vvv107300, Succ(vvv10700), Zero)
new_primQuotInt49(vvv1285, Succ(vvv12860), Zero, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, new_fromInt)
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Neg(Zero), vvv1083) → new_primQuotInt50(vvv1068, vvv10700)
new_primQuotInt50(vvv1068, vvv10700) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, new_fromInt)

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Pos(vvv12170)) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Pos(vvv12170)) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
QDP
                                                          ↳ Rewriting
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt52(vvv1212, vvv1214, vvv1213) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Zero, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt49(vvv1285, Zero, Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt55(vvv1285, vvv1288, vvv1289)
new_primQuotInt48(vvv1285, vvv1288, vvv1289, vvv1307) → new_primQuotInt54(vvv1285, vvv1288, vvv1289, vvv1307)
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Pos(vvv10730), vvv1083) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, Pos(Zero))
new_primQuotInt54(vvv802, vvv803, vvv806, vvv807) → new_primQuotInt45(vvv802, Succ(vvv803), vvv806, vvv807, Succ(vvv803))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Zero, vvv1217) → new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217)
new_primQuotInt55(vvv1285, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Pos(vvv12170)) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))
new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt45(vvv1068, Succ(Succ(vvv108400)), Succ(vvv10700), vvv1073, vvv1083) → new_primQuotInt47(vvv1068, vvv108400, Succ(vvv10700), vvv108400, vvv10700, vvv1073)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Neg(Zero)) → new_primQuotInt52(vvv1212, vvv1214, vvv1213)
new_primQuotInt49(vvv1285, Succ(vvv12860), Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt49(vvv1285, vvv12860, vvv12870, vvv1288, vvv1289)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Succ(vvv12160), vvv1217) → new_primQuotInt47(vvv1212, vvv1213, vvv1214, vvv12150, vvv12160, vvv1217)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Neg(Succ(vvv121700))) → new_primQuotInt49(vvv1212, Succ(vvv1213), vvv121700, vvv1214, Succ(vvv1213))
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Neg(Succ(vvv107300)), vvv1083) → new_primQuotInt49(vvv1068, Zero, vvv107300, Succ(vvv10700), Zero)
new_primQuotInt49(vvv1285, Succ(vvv12860), Zero, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, new_fromInt)
new_primQuotInt50(vvv1068, vvv10700) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, new_fromInt)
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Neg(Zero), vvv1083) → new_primQuotInt50(vvv1068, vvv10700)

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt49(vvv1285, Succ(vvv12860), Zero, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt49(vvv1285, Succ(vvv12860), Zero, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
QDP
                                                              ↳ Rewriting
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt52(vvv1212, vvv1214, vvv1213) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))
new_primQuotInt49(vvv1285, Zero, Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt55(vvv1285, vvv1288, vvv1289)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Zero, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt48(vvv1285, vvv1288, vvv1289, vvv1307) → new_primQuotInt54(vvv1285, vvv1288, vvv1289, vvv1307)
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Pos(vvv10730), vvv1083) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Zero, vvv1217) → new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217)
new_primQuotInt54(vvv802, vvv803, vvv806, vvv807) → new_primQuotInt45(vvv802, Succ(vvv803), vvv806, vvv807, Succ(vvv803))
new_primQuotInt55(vvv1285, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, Pos(Zero))
new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Pos(vvv12170)) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))
new_primQuotInt45(vvv1068, Succ(Succ(vvv108400)), Succ(vvv10700), vvv1073, vvv1083) → new_primQuotInt47(vvv1068, vvv108400, Succ(vvv10700), vvv108400, vvv10700, vvv1073)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Neg(Zero)) → new_primQuotInt52(vvv1212, vvv1214, vvv1213)
new_primQuotInt49(vvv1285, Succ(vvv12860), Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt49(vvv1285, vvv12860, vvv12870, vvv1288, vvv1289)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Succ(vvv12160), vvv1217) → new_primQuotInt47(vvv1212, vvv1213, vvv1214, vvv12150, vvv12160, vvv1217)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Neg(Succ(vvv121700))) → new_primQuotInt49(vvv1212, Succ(vvv1213), vvv121700, vvv1214, Succ(vvv1213))
new_primQuotInt49(vvv1285, Succ(vvv12860), Zero, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, Pos(Zero))
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Neg(Succ(vvv107300)), vvv1083) → new_primQuotInt49(vvv1068, Zero, vvv107300, Succ(vvv10700), Zero)
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Neg(Zero), vvv1083) → new_primQuotInt50(vvv1068, vvv10700)
new_primQuotInt50(vvv1068, vvv10700) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, new_fromInt)

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt50(vvv1068, vvv10700) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt50(vvv1068, vvv10700) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
QDP
                                                                  ↳ UsableRulesProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt52(vvv1212, vvv1214, vvv1213) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Zero, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt49(vvv1285, Zero, Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt55(vvv1285, vvv1288, vvv1289)
new_primQuotInt48(vvv1285, vvv1288, vvv1289, vvv1307) → new_primQuotInt54(vvv1285, vvv1288, vvv1289, vvv1307)
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Pos(vvv10730), vvv1083) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, Pos(Zero))
new_primQuotInt54(vvv802, vvv803, vvv806, vvv807) → new_primQuotInt45(vvv802, Succ(vvv803), vvv806, vvv807, Succ(vvv803))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Zero, vvv1217) → new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217)
new_primQuotInt50(vvv1068, vvv10700) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, Pos(Zero))
new_primQuotInt55(vvv1285, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Pos(vvv12170)) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))
new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt45(vvv1068, Succ(Succ(vvv108400)), Succ(vvv10700), vvv1073, vvv1083) → new_primQuotInt47(vvv1068, vvv108400, Succ(vvv10700), vvv108400, vvv10700, vvv1073)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Neg(Zero)) → new_primQuotInt52(vvv1212, vvv1214, vvv1213)
new_primQuotInt49(vvv1285, Succ(vvv12860), Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt49(vvv1285, vvv12860, vvv12870, vvv1288, vvv1289)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Succ(vvv12160), vvv1217) → new_primQuotInt47(vvv1212, vvv1213, vvv1214, vvv12150, vvv12160, vvv1217)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Neg(Succ(vvv121700))) → new_primQuotInt49(vvv1212, Succ(vvv1213), vvv121700, vvv1214, Succ(vvv1213))
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Neg(Succ(vvv107300)), vvv1083) → new_primQuotInt49(vvv1068, Zero, vvv107300, Succ(vvv10700), Zero)
new_primQuotInt49(vvv1285, Succ(vvv12860), Zero, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, Pos(Zero))
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Neg(Zero), vvv1083) → new_primQuotInt50(vvv1068, vvv10700)

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
QDP
                                                                      ↳ QReductionProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt52(vvv1212, vvv1214, vvv1213) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Zero, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt49(vvv1285, Zero, Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt55(vvv1285, vvv1288, vvv1289)
new_primQuotInt48(vvv1285, vvv1288, vvv1289, vvv1307) → new_primQuotInt54(vvv1285, vvv1288, vvv1289, vvv1307)
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Pos(vvv10730), vvv1083) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, Pos(Zero))
new_primQuotInt54(vvv802, vvv803, vvv806, vvv807) → new_primQuotInt45(vvv802, Succ(vvv803), vvv806, vvv807, Succ(vvv803))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Zero, vvv1217) → new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217)
new_primQuotInt50(vvv1068, vvv10700) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, Pos(Zero))
new_primQuotInt55(vvv1285, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Pos(vvv12170)) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))
new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt45(vvv1068, Succ(Succ(vvv108400)), Succ(vvv10700), vvv1073, vvv1083) → new_primQuotInt47(vvv1068, vvv108400, Succ(vvv10700), vvv108400, vvv10700, vvv1073)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Neg(Zero)) → new_primQuotInt52(vvv1212, vvv1214, vvv1213)
new_primQuotInt49(vvv1285, Succ(vvv12860), Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt49(vvv1285, vvv12860, vvv12870, vvv1288, vvv1289)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Succ(vvv12160), vvv1217) → new_primQuotInt47(vvv1212, vvv1213, vvv1214, vvv12150, vvv12160, vvv1217)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Neg(Succ(vvv121700))) → new_primQuotInt49(vvv1212, Succ(vvv1213), vvv121700, vvv1214, Succ(vvv1213))
new_primQuotInt49(vvv1285, Succ(vvv12860), Zero, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, Pos(Zero))
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Neg(Succ(vvv107300)), vvv1083) → new_primQuotInt49(vvv1068, Zero, vvv107300, Succ(vvv10700), Zero)
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Neg(Zero), vvv1083) → new_primQuotInt50(vvv1068, vvv10700)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_fromInt



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
QDP
                                                                          ↳ Instantiation
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt52(vvv1212, vvv1214, vvv1213) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Zero, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt49(vvv1285, Zero, Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt55(vvv1285, vvv1288, vvv1289)
new_primQuotInt48(vvv1285, vvv1288, vvv1289, vvv1307) → new_primQuotInt54(vvv1285, vvv1288, vvv1289, vvv1307)
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Pos(vvv10730), vvv1083) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, Pos(Zero))
new_primQuotInt54(vvv802, vvv803, vvv806, vvv807) → new_primQuotInt45(vvv802, Succ(vvv803), vvv806, vvv807, Succ(vvv803))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Zero, vvv1217) → new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217)
new_primQuotInt50(vvv1068, vvv10700) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, Pos(Zero))
new_primQuotInt55(vvv1285, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Pos(vvv12170)) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))
new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt45(vvv1068, Succ(Succ(vvv108400)), Succ(vvv10700), vvv1073, vvv1083) → new_primQuotInt47(vvv1068, vvv108400, Succ(vvv10700), vvv108400, vvv10700, vvv1073)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Neg(Zero)) → new_primQuotInt52(vvv1212, vvv1214, vvv1213)
new_primQuotInt49(vvv1285, Succ(vvv12860), Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt49(vvv1285, vvv12860, vvv12870, vvv1288, vvv1289)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Succ(vvv12160), vvv1217) → new_primQuotInt47(vvv1212, vvv1213, vvv1214, vvv12150, vvv12160, vvv1217)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Neg(Succ(vvv121700))) → new_primQuotInt49(vvv1212, Succ(vvv1213), vvv121700, vvv1214, Succ(vvv1213))
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Neg(Succ(vvv107300)), vvv1083) → new_primQuotInt49(vvv1068, Zero, vvv107300, Succ(vvv10700), Zero)
new_primQuotInt49(vvv1285, Succ(vvv12860), Zero, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, Pos(Zero))
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Neg(Zero), vvv1083) → new_primQuotInt50(vvv1068, vvv10700)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt48(vvv1285, vvv1288, vvv1289, vvv1307) → new_primQuotInt54(vvv1285, vvv1288, vvv1289, vvv1307) we obtained the following new rules:

new_primQuotInt48(z0, z1, z2, Pos(Zero)) → new_primQuotInt54(z0, z1, z2, Pos(Zero))
new_primQuotInt48(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt48(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt54(z0, Succ(z1), Zero, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
QDP
                                                                              ↳ Instantiation
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt52(vvv1212, vvv1214, vvv1213) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))
new_primQuotInt49(vvv1285, Zero, Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt55(vvv1285, vvv1288, vvv1289)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Zero, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Pos(vvv10730), vvv1083) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Zero, vvv1217) → new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217)
new_primQuotInt54(vvv802, vvv803, vvv806, vvv807) → new_primQuotInt45(vvv802, Succ(vvv803), vvv806, vvv807, Succ(vvv803))
new_primQuotInt48(z0, z1, z2, Pos(Zero)) → new_primQuotInt54(z0, z1, z2, Pos(Zero))
new_primQuotInt50(vvv1068, vvv10700) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, Pos(Zero))
new_primQuotInt55(vvv1285, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, Pos(Zero))
new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Pos(vvv12170)) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))
new_primQuotInt45(vvv1068, Succ(Succ(vvv108400)), Succ(vvv10700), vvv1073, vvv1083) → new_primQuotInt47(vvv1068, vvv108400, Succ(vvv10700), vvv108400, vvv10700, vvv1073)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Neg(Zero)) → new_primQuotInt52(vvv1212, vvv1214, vvv1213)
new_primQuotInt49(vvv1285, Succ(vvv12860), Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt49(vvv1285, vvv12860, vvv12870, vvv1288, vvv1289)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Succ(vvv12160), vvv1217) → new_primQuotInt47(vvv1212, vvv1213, vvv1214, vvv12150, vvv12160, vvv1217)
new_primQuotInt48(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Neg(Succ(vvv121700))) → new_primQuotInt49(vvv1212, Succ(vvv1213), vvv121700, vvv1214, Succ(vvv1213))
new_primQuotInt49(vvv1285, Succ(vvv12860), Zero, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, Pos(Zero))
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Neg(Succ(vvv107300)), vvv1083) → new_primQuotInt49(vvv1068, Zero, vvv107300, Succ(vvv10700), Zero)
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Neg(Zero), vvv1083) → new_primQuotInt50(vvv1068, vvv10700)
new_primQuotInt48(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt54(z0, Succ(z1), Zero, Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt54(vvv802, vvv803, vvv806, vvv807) → new_primQuotInt45(vvv802, Succ(vvv803), vvv806, vvv807, Succ(vvv803)) we obtained the following new rules:

new_primQuotInt54(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt45(z0, Succ(Succ(z1)), Zero, Pos(Zero), Succ(Succ(z1)))
new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt45(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt54(z0, z1, z2, Pos(Zero)) → new_primQuotInt45(z0, Succ(z1), z2, Pos(Zero), Succ(z1))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
QDP
                                                                                  ↳ DependencyGraphProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt52(vvv1212, vvv1214, vvv1213) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))
new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt45(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt54(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt45(z0, Succ(Succ(z1)), Zero, Pos(Zero), Succ(Succ(z1)))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Zero, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt49(vvv1285, Zero, Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt55(vvv1285, vvv1288, vvv1289)
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Pos(vvv10730), vvv1083) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Zero, vvv1217) → new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217)
new_primQuotInt50(vvv1068, vvv10700) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, Pos(Zero))
new_primQuotInt48(z0, z1, z2, Pos(Zero)) → new_primQuotInt54(z0, z1, z2, Pos(Zero))
new_primQuotInt54(z0, z1, z2, Pos(Zero)) → new_primQuotInt45(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt55(vvv1285, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Pos(vvv12170)) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))
new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt45(vvv1068, Succ(Succ(vvv108400)), Succ(vvv10700), vvv1073, vvv1083) → new_primQuotInt47(vvv1068, vvv108400, Succ(vvv10700), vvv108400, vvv10700, vvv1073)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Neg(Zero)) → new_primQuotInt52(vvv1212, vvv1214, vvv1213)
new_primQuotInt49(vvv1285, Succ(vvv12860), Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt49(vvv1285, vvv12860, vvv12870, vvv1288, vvv1289)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Succ(vvv12160), vvv1217) → new_primQuotInt47(vvv1212, vvv1213, vvv1214, vvv12150, vvv12160, vvv1217)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Neg(Succ(vvv121700))) → new_primQuotInt49(vvv1212, Succ(vvv1213), vvv121700, vvv1214, Succ(vvv1213))
new_primQuotInt48(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Neg(Succ(vvv107300)), vvv1083) → new_primQuotInt49(vvv1068, Zero, vvv107300, Succ(vvv10700), Zero)
new_primQuotInt49(vvv1285, Succ(vvv12860), Zero, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, Pos(Zero))
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Neg(Zero), vvv1083) → new_primQuotInt50(vvv1068, vvv10700)
new_primQuotInt48(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt54(z0, Succ(z1), Zero, Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
QDP
                                                                                      ↳ QDPOrderProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt52(vvv1212, vvv1214, vvv1213) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))
new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt45(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Zero, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt49(vvv1285, Zero, Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt55(vvv1285, vvv1288, vvv1289)
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Pos(vvv10730), vvv1083) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Zero, vvv1217) → new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217)
new_primQuotInt48(z0, z1, z2, Pos(Zero)) → new_primQuotInt54(z0, z1, z2, Pos(Zero))
new_primQuotInt50(vvv1068, vvv10700) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, Pos(Zero))
new_primQuotInt54(z0, z1, z2, Pos(Zero)) → new_primQuotInt45(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt55(vvv1285, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Pos(vvv12170)) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))
new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt45(vvv1068, Succ(Succ(vvv108400)), Succ(vvv10700), vvv1073, vvv1083) → new_primQuotInt47(vvv1068, vvv108400, Succ(vvv10700), vvv108400, vvv10700, vvv1073)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Neg(Zero)) → new_primQuotInt52(vvv1212, vvv1214, vvv1213)
new_primQuotInt49(vvv1285, Succ(vvv12860), Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt49(vvv1285, vvv12860, vvv12870, vvv1288, vvv1289)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Succ(vvv12160), vvv1217) → new_primQuotInt47(vvv1212, vvv1213, vvv1214, vvv12150, vvv12160, vvv1217)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Neg(Succ(vvv121700))) → new_primQuotInt49(vvv1212, Succ(vvv1213), vvv121700, vvv1214, Succ(vvv1213))
new_primQuotInt48(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt49(vvv1285, Succ(vvv12860), Zero, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, Pos(Zero))
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Neg(Succ(vvv107300)), vvv1083) → new_primQuotInt49(vvv1068, Zero, vvv107300, Succ(vvv10700), Zero)
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Neg(Zero), vvv1083) → new_primQuotInt50(vvv1068, vvv10700)
new_primQuotInt48(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt54(z0, Succ(z1), Zero, Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_primQuotInt52(vvv1212, vvv1214, vvv1213) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))
new_primQuotInt50(vvv1068, vvv10700) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Neg(Zero)) → new_primQuotInt52(vvv1212, vvv1214, vvv1213)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Neg(Succ(vvv121700))) → new_primQuotInt49(vvv1212, Succ(vvv1213), vvv121700, vvv1214, Succ(vvv1213))
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Neg(Succ(vvv107300)), vvv1083) → new_primQuotInt49(vvv1068, Zero, vvv107300, Succ(vvv10700), Zero)
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Neg(Zero), vvv1083) → new_primQuotInt50(vvv1068, vvv10700)
The remaining pairs can at least be oriented weakly.

new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt45(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Zero, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt49(vvv1285, Zero, Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt55(vvv1285, vvv1288, vvv1289)
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Pos(vvv10730), vvv1083) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Zero, vvv1217) → new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217)
new_primQuotInt48(z0, z1, z2, Pos(Zero)) → new_primQuotInt54(z0, z1, z2, Pos(Zero))
new_primQuotInt54(z0, z1, z2, Pos(Zero)) → new_primQuotInt45(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt55(vvv1285, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Pos(vvv12170)) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))
new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt45(vvv1068, Succ(Succ(vvv108400)), Succ(vvv10700), vvv1073, vvv1083) → new_primQuotInt47(vvv1068, vvv108400, Succ(vvv10700), vvv108400, vvv10700, vvv1073)
new_primQuotInt49(vvv1285, Succ(vvv12860), Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt49(vvv1285, vvv12860, vvv12870, vvv1288, vvv1289)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Succ(vvv12160), vvv1217) → new_primQuotInt47(vvv1212, vvv1213, vvv1214, vvv12150, vvv12160, vvv1217)
new_primQuotInt48(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt49(vvv1285, Succ(vvv12860), Zero, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, Pos(Zero))
new_primQuotInt48(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt54(z0, Succ(z1), Zero, Pos(Zero))
Used ordering: Polynomial interpretation [25]:

POL(Neg(x1)) = 1 + x1   
POL(Pos(x1)) = 0   
POL(Succ(x1)) = 0   
POL(Zero) = 1   
POL(new_primMinusNatS2(x1, x2)) = 0   
POL(new_primQuotInt45(x1, x2, x3, x4, x5)) = x4   
POL(new_primQuotInt47(x1, x2, x3, x4, x5, x6)) = x3 + x6   
POL(new_primQuotInt48(x1, x2, x3, x4)) = x2   
POL(new_primQuotInt49(x1, x2, x3, x4, x5)) = x4   
POL(new_primQuotInt50(x1, x2)) = 1   
POL(new_primQuotInt52(x1, x2, x3)) = 1 + x2   
POL(new_primQuotInt53(x1, x2, x3, x4)) = x3 + x4   
POL(new_primQuotInt54(x1, x2, x3, x4)) = x2   
POL(new_primQuotInt55(x1, x2, x3)) = x2   

The following usable rules [17] were oriented: none



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
QDP
                                                                                          ↳ DependencyGraphProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt45(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Zero, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt49(vvv1285, Zero, Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt55(vvv1285, vvv1288, vvv1289)
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Pos(vvv10730), vvv1083) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Zero, vvv1217) → new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217)
new_primQuotInt48(z0, z1, z2, Pos(Zero)) → new_primQuotInt54(z0, z1, z2, Pos(Zero))
new_primQuotInt54(z0, z1, z2, Pos(Zero)) → new_primQuotInt45(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt55(vvv1285, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Pos(vvv12170)) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))
new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt45(vvv1068, Succ(Succ(vvv108400)), Succ(vvv10700), vvv1073, vvv1083) → new_primQuotInt47(vvv1068, vvv108400, Succ(vvv10700), vvv108400, vvv10700, vvv1073)
new_primQuotInt49(vvv1285, Succ(vvv12860), Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt49(vvv1285, vvv12860, vvv12870, vvv1288, vvv1289)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Succ(vvv12160), vvv1217) → new_primQuotInt47(vvv1212, vvv1213, vvv1214, vvv12150, vvv12160, vvv1217)
new_primQuotInt48(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt49(vvv1285, Succ(vvv12860), Zero, vvv1288, vvv1289) → new_primQuotInt48(vvv1285, vvv1288, vvv1289, Pos(Zero))
new_primQuotInt48(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt54(z0, Succ(z1), Zero, Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 2 SCCs with 3 less nodes.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ DependencyGraphProof
                                                                                            ↳ AND
QDP
                                                                                                ↳ Instantiation
                                                                                              ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt45(vvv1068, Succ(Succ(vvv108400)), Succ(vvv10700), vvv1073, vvv1083) → new_primQuotInt47(vvv1068, vvv108400, Succ(vvv10700), vvv108400, vvv10700, vvv1073)
new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt45(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Zero, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Succ(vvv12160), vvv1217) → new_primQuotInt47(vvv1212, vvv1213, vvv1214, vvv12150, vvv12160, vvv1217)
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Pos(vvv10730), vvv1083) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Zero, vvv1217) → new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217)
new_primQuotInt48(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt48(z0, z1, z2, Pos(Zero)) → new_primQuotInt54(z0, z1, z2, Pos(Zero))
new_primQuotInt54(z0, z1, z2, Pos(Zero)) → new_primQuotInt45(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Pos(vvv12170)) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))
new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt48(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt54(z0, Succ(z1), Zero, Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt48(z0, z1, z2, Pos(Zero)) → new_primQuotInt54(z0, z1, z2, Pos(Zero)) we obtained the following new rules:

new_primQuotInt48(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt54(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt48(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt54(z0, Succ(z1), Zero, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ DependencyGraphProof
                                                                                            ↳ AND
                                                                                              ↳ QDP
                                                                                                ↳ Instantiation
QDP
                                                                                                    ↳ Instantiation
                                                                                              ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt45(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Zero, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Pos(vvv10730), vvv1083) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Zero, vvv1217) → new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217)
new_primQuotInt54(z0, z1, z2, Pos(Zero)) → new_primQuotInt45(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Pos(vvv12170)) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))
new_primQuotInt45(vvv1068, Succ(Succ(vvv108400)), Succ(vvv10700), vvv1073, vvv1083) → new_primQuotInt47(vvv1068, vvv108400, Succ(vvv10700), vvv108400, vvv10700, vvv1073)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Succ(vvv12160), vvv1217) → new_primQuotInt47(vvv1212, vvv1213, vvv1214, vvv12150, vvv12160, vvv1217)
new_primQuotInt48(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt48(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt54(z0, Succ(z1), Zero, Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt54(z0, z1, z2, Pos(Zero)) → new_primQuotInt45(z0, Succ(z1), z2, Pos(Zero), Succ(z1)) we obtained the following new rules:

new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt45(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt54(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt45(z0, Succ(Succ(z1)), Zero, Pos(Zero), Succ(Succ(z1)))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ DependencyGraphProof
                                                                                            ↳ AND
                                                                                              ↳ QDP
                                                                                                ↳ Instantiation
                                                                                                  ↳ QDP
                                                                                                    ↳ Instantiation
QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                              ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt45(vvv1068, Succ(Succ(vvv108400)), Succ(vvv10700), vvv1073, vvv1083) → new_primQuotInt47(vvv1068, vvv108400, Succ(vvv10700), vvv108400, vvv10700, vvv1073)
new_primQuotInt54(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt45(z0, Succ(Succ(z1)), Zero, Pos(Zero), Succ(Succ(z1)))
new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt45(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Zero, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Succ(vvv12160), vvv1217) → new_primQuotInt47(vvv1212, vvv1213, vvv1214, vvv12150, vvv12160, vvv1217)
new_primQuotInt45(vvv1068, Succ(Zero), Succ(vvv10700), Pos(vvv10730), vvv1083) → new_primQuotInt48(vvv1068, Succ(vvv10700), Zero, Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Zero, vvv1217) → new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217)
new_primQuotInt48(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Pos(vvv12170)) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))
new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt48(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt54(z0, Succ(z1), Zero, Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 3 less nodes.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ DependencyGraphProof
                                                                                            ↳ AND
                                                                                              ↳ QDP
                                                                                                ↳ Instantiation
                                                                                                  ↳ QDP
                                                                                                    ↳ Instantiation
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
QDP
                                                                                                            ↳ QDPOrderProof
                                                                                              ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt45(vvv1068, Succ(Succ(vvv108400)), Succ(vvv10700), vvv1073, vvv1083) → new_primQuotInt47(vvv1068, vvv108400, Succ(vvv10700), vvv108400, vvv10700, vvv1073)
new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt45(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Zero, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Succ(vvv12160), vvv1217) → new_primQuotInt47(vvv1212, vvv1213, vvv1214, vvv12150, vvv12160, vvv1217)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Zero, vvv1217) → new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217)
new_primQuotInt48(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Pos(vvv12170)) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))
new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Zero, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Zero, vvv1217) → new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217)
The remaining pairs can at least be oriented weakly.

new_primQuotInt45(vvv1068, Succ(Succ(vvv108400)), Succ(vvv10700), vvv1073, vvv1083) → new_primQuotInt47(vvv1068, vvv108400, Succ(vvv10700), vvv108400, vvv10700, vvv1073)
new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt45(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Succ(vvv12160), vvv1217) → new_primQuotInt47(vvv1212, vvv1213, vvv1214, vvv12150, vvv12160, vvv1217)
new_primQuotInt48(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Pos(vvv12170)) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))
new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
Used ordering: Matrix interpretation [3]:
Non-tuple symbols:
M( Succ(x1) ) =
/0\
\1/
+
/11\
\00/
·x1

M( new_primMinusNatS2(x1, x2) ) =
/0\
\1/
+
/10\
\00/
·x1+
/00\
\00/
·x2

M( Zero ) =
/0\
\1/

M( Pos(x1) ) =
/1\
\1/
+
/01\
\00/
·x1

Tuple symbols:
M( new_primQuotInt54(x1, ..., x4) ) = 0+
[0,0]
·x1+
[1,1]
·x2+
[1,0]
·x3+
[1,0]
·x4

M( new_primQuotInt48(x1, ..., x4) ) = 0+
[0,0]
·x1+
[1,1]
·x2+
[1,0]
·x3+
[1,0]
·x4

M( new_primQuotInt47(x1, ..., x6) ) = 1+
[0,0]
·x1+
[1,1]
·x2+
[1,1]
·x3+
[0,0]
·x4+
[0,0]
·x5+
[0,1]
·x6

M( new_primQuotInt53(x1, ..., x4) ) = 0+
[0,0]
·x1+
[1,1]
·x2+
[1,1]
·x3+
[0,1]
·x4

M( new_primQuotInt45(x1, ..., x5) ) = 0+
[0,0]
·x1+
[1,0]
·x2+
[1,1]
·x3+
[0,1]
·x4+
[0,0]
·x5


Matrix type:
We used a basic matrix type which is not further parametrizeable.


As matrix orders are CE-compatible, we used usable rules w.r.t. argument filtering in the order.
The following usable rules [17] were oriented:

new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ DependencyGraphProof
                                                                                            ↳ AND
                                                                                              ↳ QDP
                                                                                                ↳ Instantiation
                                                                                                  ↳ QDP
                                                                                                    ↳ Instantiation
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ QDPOrderProof
QDP
                                                                                                                ↳ DependencyGraphProof
                                                                                              ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt45(vvv1068, Succ(Succ(vvv108400)), Succ(vvv10700), vvv1073, vvv1083) → new_primQuotInt47(vvv1068, vvv108400, Succ(vvv10700), vvv108400, vvv10700, vvv1073)
new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt45(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Succ(vvv12160), vvv1217) → new_primQuotInt47(vvv1212, vvv1213, vvv1214, vvv12150, vvv12160, vvv1217)
new_primQuotInt48(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt53(vvv1212, vvv1213, vvv1214, vvv1217) → new_primQuotInt45(vvv1212, new_primMinusNatS2(Succ(vvv1213), vvv1214), vvv1214, vvv1217, new_primMinusNatS2(Succ(vvv1213), vvv1214))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Pos(vvv12170)) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ DependencyGraphProof
                                                                                            ↳ AND
                                                                                              ↳ QDP
                                                                                                ↳ Instantiation
                                                                                                  ↳ QDP
                                                                                                    ↳ Instantiation
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ QDPOrderProof
                                                                                                              ↳ QDP
                                                                                                                ↳ DependencyGraphProof
QDP
                                                                                                                    ↳ UsableRulesProof
                                                                                              ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt45(vvv1068, Succ(Succ(vvv108400)), Succ(vvv10700), vvv1073, vvv1083) → new_primQuotInt47(vvv1068, vvv108400, Succ(vvv10700), vvv108400, vvv10700, vvv1073)
new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt45(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Succ(vvv12160), vvv1217) → new_primQuotInt47(vvv1212, vvv1213, vvv1214, vvv12150, vvv12160, vvv1217)
new_primQuotInt48(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Pos(vvv12170)) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ DependencyGraphProof
                                                                                            ↳ AND
                                                                                              ↳ QDP
                                                                                                ↳ Instantiation
                                                                                                  ↳ QDP
                                                                                                    ↳ Instantiation
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ QDPOrderProof
                                                                                                              ↳ QDP
                                                                                                                ↳ DependencyGraphProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ UsableRulesProof
QDP
                                                                                                                        ↳ QReductionProof
                                                                                              ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt45(vvv1068, Succ(Succ(vvv108400)), Succ(vvv10700), vvv1073, vvv1083) → new_primQuotInt47(vvv1068, vvv108400, Succ(vvv10700), vvv108400, vvv10700, vvv1073)
new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt45(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Succ(vvv12160), vvv1217) → new_primQuotInt47(vvv1212, vvv1213, vvv1214, vvv12150, vvv12160, vvv1217)
new_primQuotInt48(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Pos(vvv12170)) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))

R is empty.
The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ DependencyGraphProof
                                                                                            ↳ AND
                                                                                              ↳ QDP
                                                                                                ↳ Instantiation
                                                                                                  ↳ QDP
                                                                                                    ↳ Instantiation
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ QDPOrderProof
                                                                                                              ↳ QDP
                                                                                                                ↳ DependencyGraphProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ UsableRulesProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ QReductionProof
QDP
                                                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt45(vvv1068, Succ(Succ(vvv108400)), Succ(vvv10700), vvv1073, vvv1083) → new_primQuotInt47(vvv1068, vvv108400, Succ(vvv10700), vvv108400, vvv10700, vvv1073)
new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt45(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Succ(vvv12160), vvv1217) → new_primQuotInt47(vvv1212, vvv1213, vvv1214, vvv12150, vvv12160, vvv1217)
new_primQuotInt48(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Pos(vvv12170)) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt45(vvv1068, Succ(Succ(vvv108400)), Succ(vvv10700), vvv1073, vvv1083) → new_primQuotInt47(vvv1068, vvv108400, Succ(vvv10700), vvv108400, vvv10700, vvv1073) we obtained the following new rules:

new_primQuotInt45(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt47(z0, x1, Succ(z2), x1, z2, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ DependencyGraphProof
                                                                                            ↳ AND
                                                                                              ↳ QDP
                                                                                                ↳ Instantiation
                                                                                                  ↳ QDP
                                                                                                    ↳ Instantiation
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ QDPOrderProof
                                                                                                              ↳ QDP
                                                                                                                ↳ DependencyGraphProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ UsableRulesProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ QReductionProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
QDP
                                                                                                                                ↳ NonInfProof
                                                                                              ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt45(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt47(z0, x1, Succ(z2), x1, z2, Pos(Zero))
new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt45(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Succ(vvv12160), vvv1217) → new_primQuotInt47(vvv1212, vvv1213, vvv1214, vvv12150, vvv12160, vvv1217)
new_primQuotInt48(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Pos(vvv12170)) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The DP Problem is simplified using the Induction Calculus [18] with the following steps:
Note that final constraints are written in bold face.


For Pair new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt45(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1)) the following chains were created:




For Pair new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Succ(vvv12160), vvv1217) → new_primQuotInt47(vvv1212, vvv1213, vvv1214, vvv12150, vvv12160, vvv1217) the following chains were created:




For Pair new_primQuotInt48(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero)) the following chains were created:




For Pair new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Pos(vvv12170)) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero)) the following chains were created:




For Pair new_primQuotInt45(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt47(z0, x1, Succ(z2), x1, z2, Pos(Zero)) the following chains were created:




To summarize, we get the following constraints P for the following pairs.



The constraints for P> respective Pbound are constructed from P where we just replace every occurence of "t ≥ s" in P by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for Pbound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation [18]:

POL(Pos(x1)) = 1   
POL(Succ(x1)) = 1 + x1   
POL(Zero) = 0   
POL(c) = -1   
POL(new_primQuotInt45(x1, x2, x3, x4, x5)) = x1 + x2 + x3 - x4 - x5   
POL(new_primQuotInt47(x1, x2, x3, x4, x5, x6)) = 1 + x1 + x2 - x4 + x5 - x6   
POL(new_primQuotInt48(x1, x2, x3, x4)) = x1 + x3   
POL(new_primQuotInt54(x1, x2, x3, x4)) = x1 + x3 - x4   

The following pairs are in P>:

new_primQuotInt48(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero))
The following pairs are in Pbound:

new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt45(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt48(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Pos(vvv12170)) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))
new_primQuotInt45(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt47(z0, x1, Succ(z2), x1, z2, Pos(Zero))
There are no usable rules

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ DependencyGraphProof
                                                                                            ↳ AND
                                                                                              ↳ QDP
                                                                                                ↳ Instantiation
                                                                                                  ↳ QDP
                                                                                                    ↳ Instantiation
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ QDPOrderProof
                                                                                                              ↳ QDP
                                                                                                                ↳ DependencyGraphProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ UsableRulesProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ QReductionProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ NonInfProof
QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                              ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt54(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt45(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt45(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt47(z0, x1, Succ(z2), x1, z2, Pos(Zero))
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Succ(vvv12160), vvv1217) → new_primQuotInt47(vvv1212, vvv1213, vvv1214, vvv12150, vvv12160, vvv1217)
new_primQuotInt47(vvv1212, vvv1213, vvv1214, Zero, Succ(vvv12160), Pos(vvv12170)) → new_primQuotInt48(vvv1212, vvv1214, Succ(vvv1213), Pos(Zero))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 3 less nodes.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ DependencyGraphProof
                                                                                            ↳ AND
                                                                                              ↳ QDP
                                                                                                ↳ Instantiation
                                                                                                  ↳ QDP
                                                                                                    ↳ Instantiation
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ QDPOrderProof
                                                                                                              ↳ QDP
                                                                                                                ↳ DependencyGraphProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ UsableRulesProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ QReductionProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ NonInfProof
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
QDP
                                                                                                                                        ↳ QDPSizeChangeProof
                                                                                              ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt47(vvv1212, vvv1213, vvv1214, Succ(vvv12150), Succ(vvv12160), vvv1217) → new_primQuotInt47(vvv1212, vvv1213, vvv1214, vvv12150, vvv12160, vvv1217)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ DependencyGraphProof
                                                                                            ↳ AND
                                                                                              ↳ QDP
QDP
                                                                                                ↳ UsableRulesProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt49(vvv1285, Succ(vvv12860), Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt49(vvv1285, vvv12860, vvv12870, vvv1288, vvv1289)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ DependencyGraphProof
                                                                                            ↳ AND
                                                                                              ↳ QDP
                                                                                              ↳ QDP
                                                                                                ↳ UsableRulesProof
QDP
                                                                                                    ↳ QReductionProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt49(vvv1285, Succ(vvv12860), Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt49(vvv1285, vvv12860, vvv12870, vvv1288, vvv1289)

R is empty.
The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ DependencyGraphProof
                                                                                            ↳ AND
                                                                                              ↳ QDP
                                                                                              ↳ QDP
                                                                                                ↳ UsableRulesProof
                                                                                                  ↳ QDP
                                                                                                    ↳ QReductionProof
QDP
                                                                                                        ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt49(vvv1285, Succ(vvv12860), Succ(vvv12870), vvv1288, vvv1289) → new_primQuotInt49(vvv1285, vvv12860, vvv12870, vvv1288, vvv1289)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt56(vvv827, vvv828, Succ(vvv8290), Succ(vvv8300), vvv831, vvv832) → new_primQuotInt56(vvv827, vvv828, vvv8290, vvv8300, vvv831, vvv832)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt57(vvv553, Succ(vvv5540), Succ(vvv5550), vvv556, vvv557) → new_primQuotInt57(vvv553, vvv5540, vvv5550, vvv556, vvv557)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt58(vvv802, vvv803, Succ(vvv8040), Succ(vvv8050), vvv806, vvv807) → new_primQuotInt58(vvv802, vvv803, vvv8040, vvv8050, vvv806, vvv807)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt59(vvv541, Succ(vvv5420), Succ(vvv5430), vvv544, vvv545) → new_primQuotInt59(vvv541, vvv5420, vvv5430, vvv544, vvv545)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt60(vvv820, vvv821, Succ(vvv8220), Succ(vvv8230), vvv824, vvv825) → new_primQuotInt60(vvv820, vvv821, vvv8220, vvv8230, vvv824, vvv825)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt61(vvv527, Succ(vvv5280), Succ(vvv5290), vvv530, vvv531) → new_primQuotInt61(vvv527, vvv5280, vvv5290, vvv530, vvv531)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt62(vvv436, vvv437, Succ(vvv4380), Succ(vvv4390), vvv440, vvv441) → new_primQuotInt62(vvv436, vvv437, vvv4380, vvv4390, vvv440, vvv441)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt63(vvv335, Succ(vvv3360), Succ(vvv3370), vvv338, vvv339) → new_primQuotInt63(vvv335, vvv3360, vvv3370, vvv338, vvv339)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt64(vvv51, Succ(vvv22500), Succ(vvv111000), vvv224, vvv52) → new_primQuotInt64(vvv51, vvv22500, vvv111000, vvv224, vvv52)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt65(vvv699, vvv700, Succ(vvv7010), Succ(vvv7020), vvv703, vvv704) → new_primQuotInt65(vvv699, vvv700, vvv7010, vvv7020, vvv703, vvv704)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt66(vvv521, Succ(vvv5220), Succ(vvv5230), vvv524, vvv525) → new_primQuotInt66(vvv521, vvv5220, vvv5230, vvv524, vvv525)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt67(vvv422, vvv423, Succ(vvv4240), Succ(vvv4250), vvv426, vvv427) → new_primQuotInt67(vvv422, vvv423, vvv4240, vvv4250, vvv426, vvv427)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt68(vvv324, Succ(vvv3250), Succ(vvv3260), vvv327, vvv328) → new_primQuotInt68(vvv324, vvv3250, vvv3260, vvv327, vvv328)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt69(vvv46, Succ(vvv22300), Succ(vvv108000), vvv222, vvv47) → new_primQuotInt69(vvv46, vvv22300, vvv108000, vvv222, vvv47)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt70(vvv46, Succ(vvv2050), Succ(vvv1890), vvv108, vvv47) → new_primQuotInt70(vvv46, vvv2050, vvv1890, vvv108, vvv47)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt71(vvv463, vvv464, Succ(vvv4650), Succ(vvv4660), vvv467) → new_primQuotInt71(vvv463, vvv464, vvv4650, vvv4660, vvv467)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt72(vvv341, Succ(vvv3420), Succ(vvv3430), vvv344) → new_primQuotInt72(vvv341, vvv3420, vvv3430, vvv344)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt73(vvv443, vvv444, Succ(vvv4450), Succ(vvv4460), vvv447, vvv448) → new_primQuotInt73(vvv443, vvv444, vvv4450, vvv4460, vvv447, vvv448)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt74(vvv388, Succ(vvv3890), Succ(vvv3900), vvv391, vvv392) → new_primQuotInt74(vvv388, vvv3890, vvv3900, vvv391, vvv392)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt75(vvv281, Succ(vvv2820), Succ(vvv2830), vvv284, vvv285) → new_primQuotInt75(vvv281, vvv2820, vvv2830, vvv284, vvv285)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt76(vvv657, vvv658, Succ(vvv6590), Succ(vvv6600)) → new_primQuotInt76(vvv657, vvv658, vvv6590, vvv6600)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt77(vvv631, vvv632, Succ(vvv6330), Succ(vvv6340)) → new_primQuotInt77(vvv631, vvv632, vvv6330, vvv6340)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ DependencyGraphProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Succ(vvv87500)), vvv888) → new_primQuotInt80(vvv870, Zero, vvv87500, Succ(vvv8720), Zero)
new_primQuotInt90(vvv115, Pos(Succ(vvv46900)), Pos(Zero), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt90(vvv115, Pos(Zero), Pos(Succ(vvv28900)), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Zero, vvv1011, vvv1034) → new_primQuotInt94(vvv1006, new_primMinusNatS2(Succ(vvv103500), Zero), Zero, vvv1011, new_primMinusNatS2(Succ(vvv103500), Zero))
new_primQuotInt94(vvv1006, Succ(Zero), Zero, vvv1011, vvv1034) → new_primQuotInt94(vvv1006, new_primMinusNatS2(Zero, Zero), Zero, vvv1011, new_primMinusNatS2(Zero, Zero))
new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), new_fromInt)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt86(vvv982, vvv983, vvv984, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt130(vvv813, vvv814, vvv817, vvv818) → new_primQuotInt121(vvv813, Succ(vvv814), vvv817, vvv818, Succ(vvv814))
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Succ(vvv125400)), vvv1255) → new_primQuotInt125(vvv1249, Zero, vvv125400, Succ(vvv12510), Zero)
new_primQuotInt96(vvv115, Pos(Zero), vvv503) → new_primQuotInt90(vvv115, new_error, vvv503, new_error)
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Succ(vvv104600)), vvv1052) → new_primQuotInt109(vvv1041, Zero, vvv104600, Succ(vvv10430), Zero)
new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Succ(vvv12510), vvv1254, vvv1255) → new_primQuotInt123(vvv1249, vvv125600, Succ(vvv12510), vvv125600, vvv12510, vvv1254)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), new_fromInt)
new_primQuotInt118(vvv115, Succ(vvv471000), Succ(vvv316000), vvv470) → new_primQuotInt118(vvv115, vvv471000, vvv316000, vvv470)
new_primQuotInt98(vvv1279, Zero, Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt104(vvv1279, vvv1282, vvv1283)
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Pos(vvv10460), vvv1052) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, new_fromInt)
new_primQuotInt120(vvv115, Neg(Zero), vvv505) → new_primQuotInt95(vvv115, new_error, vvv505, new_error)
new_primQuotInt93(vvv115, Pos(Succ(vvv46800)), vvv503) → new_primQuotInt78(vvv115, Zero, vvv46800, vvv503, Zero)
new_primQuotInt80(vvv1236, Succ(vvv12370), Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt80(vvv1236, vvv12370, vvv12380, vvv1239, vvv1240)
new_primQuotInt78(vvv870, Succ(Zero), Zero, vvv875, vvv888) → new_primQuotInt78(vvv870, new_primMinusNatS2(Zero, Zero), Zero, vvv875, new_primMinusNatS2(Zero, Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Neg(vvv12100)) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), new_fromInt)
new_primQuotInt118(vvv115, Zero, Succ(vvv316000), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt118(vvv115, Succ(vvv471000), Zero, vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Neg(vvv10110), vvv1034) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, new_fromInt)
new_primQuotInt90(vvv115, Neg(Succ(vvv46900)), Neg(Zero), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt90(vvv115, Neg(Zero), Neg(Succ(vvv28900)), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt122(vvv115, Pos(Zero), vvv505) → new_primQuotInt90(vvv115, new_error, vvv505, new_error)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Neg(vvv9870)) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), new_fromInt)
new_primQuotInt125(vvv1334, Zero, Succ(vvv13360), vvv1337, vvv1338) → new_primQuotInt131(vvv1334, vvv1337, vvv1338)
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Zero), vvv1255) → new_primQuotInt126(vvv1249, vvv12510)
new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt90(vvv115, Pos(Succ(Succ(vvv469000))), Pos(Succ(Succ(vvv289000))), vvv468) → new_primQuotInt91(vvv115, vvv469000, vvv289000, vvv468)
new_primQuotInt122(vvv115, Neg(Succ(vvv47000)), vvv505) → new_primQuotInt121(vvv115, Zero, vvv47000, vvv505, Zero)
new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Zero, vvv1254, vvv1255) → new_primQuotInt121(vvv1249, new_primMinusNatS2(Succ(vvv125600), Zero), Zero, vvv1254, new_primMinusNatS2(Succ(vvv125600), Zero))
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt92(vvv115, vvv468) → new_primQuotInt93(vvv115, vvv468, new_fromInt)
new_primQuotInt122(vvv115, Neg(Zero), vvv505) → new_primQuotInt95(vvv115, new_error, vvv505, new_error)
new_primQuotInt121(vvv1249, Zero, vvv1251, Neg(Succ(vvv125400)), vvv1255) → new_primQuotInt127(vvv1249, vvv1251)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Succ(vvv13260), vvv1327) → new_primQuotInt123(vvv1322, vvv1323, vvv1324, vvv13250, vvv13260, vvv1327)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Zero)) → new_primQuotInt113(vvv1194, vvv1196, vvv1195)
new_primQuotInt95(vvv115, Pos(Succ(vvv47100)), Pos(Zero), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Pos(Zero), Pos(Succ(vvv31600)), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Neg(Succ(vvv47100)), Pos(vvv3160), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, new_fromInt)
new_primQuotInt131(vvv1334, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, new_fromInt)
new_primQuotInt82(vvv1236, vvv1239, vvv1240, vvv1246) → new_primQuotInt88(vvv1236, vvv1239, vvv1240, vvv1246)
new_primQuotInt90(vvv115, Pos(Succ(vvv46900)), Neg(vvv2890), vvv468) → new_primQuotInt93(vvv115, vvv468, new_fromInt)
new_primQuotInt90(vvv115, Neg(Succ(vvv46900)), Neg(Succ(vvv28900)), vvv468) → new_primQuotInt91(vvv115, vvv46900, vvv28900, vvv468)
new_primQuotInt96(vvv115, Neg(Zero), vvv503) → new_primQuotInt95(vvv115, new_error, vvv503, new_error)
new_primQuotInt95(vvv115, Pos(Succ(Succ(vvv471000))), Pos(Succ(Succ(vvv316000))), vvv470) → new_primQuotInt118(vvv115, vvv471000, vvv316000, vvv470)
new_primQuotInt128(vvv1322, vvv1324, vvv1323) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), new_fromInt)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Succ(vvv121000))) → new_primQuotInt98(vvv1205, Succ(vvv1206), vvv121000, vvv1207, Succ(vvv1206))
new_primQuotInt101(vvv1006, vvv1008) → new_primQuotInt83(vvv1006, new_rem0(vvv1008))
new_primQuotInt106(vvv1041, Succ(Zero), Zero, vvv1046, vvv1052) → new_primQuotInt106(vvv1041, new_primMinusNatS2(Zero, Zero), Zero, vvv1046, new_primMinusNatS2(Zero, Zero))
new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Zero, vvv875, vvv888) → new_primQuotInt78(vvv870, new_primMinusNatS2(Succ(vvv88900), Zero), Zero, vvv875, new_primMinusNatS2(Succ(vvv88900), Zero))
new_primQuotInt120(vvv115, Pos(Succ(vvv47000)), vvv505) → new_primQuotInt106(vvv115, Zero, vvv47000, vvv505, Zero)
new_primQuotInt100(vvv1279, vvv1282, vvv1283, vvv1306) → new_primQuotInt105(vvv1279, vvv1282, vvv1283, vvv1306)
new_primQuotInt95(vvv115, Pos(Succ(vvv47100)), Neg(vvv3160), vvv470) → new_primQuotInt120(vvv115, vvv470, new_fromInt)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt98(vvv1006, Zero, vvv101100, Succ(vvv10080), Zero)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), new_fromInt)
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Zero), vvv888) → new_primQuotInt81(vvv870, vvv8720)
new_primQuotInt95(vvv115, Pos(Succ(Zero)), Pos(Succ(Succ(vvv316000))), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Pos(Succ(Succ(vvv471000))), Pos(Succ(Zero)), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), new_fromInt)
new_primQuotInt90(vvv115, Neg(Zero), Pos(Succ(vvv28900)), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt90(vvv115, Pos(Zero), Neg(Succ(vvv28900)), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt116(vvv1272, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, new_fromInt)
new_primQuotInt125(vvv1334, Succ(vvv13350), Zero, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, new_fromInt)
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt109(vvv1272, Zero, Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt116(vvv1272, vvv1275, vvv1276)
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Zero), vvv1052) → new_primQuotInt110(vvv1041, vvv10430)
new_primQuotInt84(vvv870, vvv872) → new_primQuotInt83(vvv870, new_rem(vvv872))
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Succ(vvv9860), vvv987) → new_primQuotInt79(vvv982, vvv983, vvv984, vvv9850, vvv9860, vvv987)
new_primQuotInt119(vvv115, vvv470) → new_primQuotInt120(vvv115, vvv470, new_fromInt)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Zero)) → new_primQuotInt85(vvv982, vvv984, vvv983)
new_primQuotInt115(vvv415, vvv4200, vvv416, vvv481) → new_primQuotInt94(vvv415, Succ(vvv4200), vvv416, vvv481, Succ(vvv4200))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Succ(vvv119900))) → new_primQuotInt109(vvv1194, Succ(vvv1195), vvv119900, vvv1196, Succ(vvv1195))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Succ(vvv98700))) → new_primQuotInt80(vvv982, Succ(vvv983), vvv98700, vvv984, Succ(vvv983))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Zero, vvv987) → new_primQuotInt86(vvv982, vvv983, vvv984, vvv987)
new_primQuotInt105(vvv706, vvv707, vvv710, vvv711) → new_primQuotInt106(vvv706, Succ(vvv707), vvv710, vvv711, Succ(vvv707))
new_primQuotInt93(vvv115, Neg(Succ(vvv46800)), vvv503) → new_primQuotInt94(vvv115, Zero, vvv46800, vvv503, Zero)
new_primQuotInt113(vvv1194, vvv1196, vvv1195) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), new_fromInt)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Zero, vvv1327) → new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327)
new_primQuotInt90(vvv115, Pos(Succ(Zero)), Pos(Succ(Succ(vvv289000))), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt90(vvv115, Pos(Succ(Succ(vvv469000))), Pos(Succ(Zero)), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt83(vvv870, vvv911) → new_primQuotInt89(vvv870, vvv911, new_fromInt)
new_primQuotInt109(vvv1272, Succ(vvv12730), Zero, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, new_fromInt)
new_primQuotInt110(vvv1041, vvv10430) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, new_fromInt)
new_primQuotInt127(vvv1249, vvv1251) → new_primQuotInt111(vvv1249, new_rem2(vvv1251))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Zero, vvv1046, vvv1052) → new_primQuotInt106(vvv1041, new_primMinusNatS2(Succ(vvv105300), Zero), Zero, vvv1046, new_primMinusNatS2(Succ(vvv105300), Zero))
new_primQuotInt95(vvv115, Neg(Zero), Neg(Succ(vvv31600)), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Neg(Succ(vvv47100)), Neg(Zero), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt121(vvv1249, Zero, vvv1251, Pos(Succ(vvv125400)), vvv1255) → new_primQuotInt111(vvv1249, new_rem2(vvv1251))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt78(vvv870, Zero, vvv872, Pos(Succ(vvv87500)), vvv888) → new_primQuotInt83(vvv870, new_rem(vvv872))
new_primQuotInt112(vvv1041, vvv1043) → new_primQuotInt111(vvv1041, new_rem1(vvv1043))
new_primQuotInt117(vvv1249, vvv1261, vvv1262) → new_primQuotInt95(vvv1249, vvv1261, vvv1262, vvv1261)
new_primQuotInt87(vvv1236, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, new_fromInt)
new_primQuotInt125(vvv1334, Succ(vvv13350), Succ(vvv13360), vvv1337, vvv1338) → new_primQuotInt125(vvv1334, vvv13350, vvv13360, vvv1337, vvv1338)
new_primQuotInt106(vvv1041, Zero, vvv1043, Pos(Succ(vvv104600)), vvv1052) → new_primQuotInt111(vvv1041, new_rem1(vvv1043))
new_primQuotInt95(vvv115, Pos(Zero), Neg(Succ(vvv31600)), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Neg(Zero), Pos(Succ(vvv31600)), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt122(vvv115, Pos(Succ(vvv47000)), vvv505) → new_primQuotInt106(vvv115, Zero, vvv47000, vvv505, Zero)
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Zero, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Zero, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt80(vvv1236, Zero, Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt87(vvv1236, vvv1239, vvv1240)
new_primQuotInt91(vvv115, Succ(vvv469000), Zero, vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt91(vvv115, Zero, Succ(vvv289000), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt121(vvv1249, Succ(Zero), Zero, vvv1254, vvv1255) → new_primQuotInt121(vvv1249, new_primMinusNatS2(Zero, Zero), Zero, vvv1254, new_primMinusNatS2(Zero, Zero))
new_primQuotInt111(vvv1249, vvv1261) → new_primQuotInt117(vvv1249, vvv1261, new_fromInt)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt109(vvv1272, Succ(vvv12730), Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt109(vvv1272, vvv12730, vvv12740, vvv1275, vvv1276)
new_primQuotInt108(vvv1272, vvv1275, vvv1276, vvv1298) → new_primQuotInt115(vvv1272, vvv1275, vvv1276, vvv1298)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Zero)) → new_primQuotInt128(vvv1322, vvv1324, vvv1323)
new_primQuotInt94(vvv1006, Zero, vvv1008, Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt83(vvv1006, new_rem0(vvv1008))
new_primQuotInt93(vvv115, Pos(Zero), vvv503) → new_primQuotInt90(vvv115, new_error, vvv503, new_error)
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, new_fromInt)
new_primQuotInt126(vvv1249, vvv12510) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, new_fromInt)
new_primQuotInt124(vvv1334, vvv1337, vvv1338, vvv1339) → new_primQuotInt130(vvv1334, vvv1337, vvv1338, vvv1339)
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, new_fromInt)
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Neg(vvv8750), vvv888) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, new_fromInt)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt80(vvv1236, Succ(vvv12370), Zero, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, new_fromInt)
new_primQuotInt120(vvv115, Pos(Zero), vvv505) → new_primQuotInt90(vvv115, new_error, vvv505, new_error)
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Pos(vvv12540), vvv1255) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, new_fromInt)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt120(vvv115, Neg(Succ(vvv47000)), vvv505) → new_primQuotInt121(vvv115, Zero, vvv47000, vvv505, Zero)
new_primQuotInt106(vvv1041, Zero, vvv1043, Neg(Succ(vvv104600)), vvv1052) → new_primQuotInt112(vvv1041, vvv1043)
new_primQuotInt78(vvv870, Zero, vvv872, Neg(Succ(vvv87500)), vvv888) → new_primQuotInt84(vvv870, vvv872)
new_primQuotInt90(vvv115, Neg(Succ(vvv46900)), Pos(vvv2890), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt98(vvv1279, Succ(vvv12800), Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt98(vvv1279, vvv12800, vvv12810, vvv1282, vvv1283)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Succ(vvv132700))) → new_primQuotInt125(vvv1322, Succ(vvv1323), vvv132700, vvv1324, Succ(vvv1323))
new_primQuotInt89(vvv870, vvv911, vvv922) → new_primQuotInt90(vvv870, vvv911, vvv922, vvv911)
new_primQuotInt81(vvv870, vvv8720) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, new_fromInt)
new_primQuotInt96(vvv115, Pos(Succ(vvv46800)), vvv503) → new_primQuotInt78(vvv115, Zero, vvv46800, vvv503, Zero)
new_primQuotInt94(vvv1006, Zero, vvv1008, Neg(Succ(vvv101100)), vvv1034) → new_primQuotInt101(vvv1006, vvv1008)
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt91(vvv115, Succ(vvv469000), Succ(vvv289000), vvv468) → new_primQuotInt91(vvv115, vvv469000, vvv289000, vvv468)
new_primQuotInt96(vvv115, Neg(Succ(vvv46800)), vvv503) → new_primQuotInt94(vvv115, Zero, vvv46800, vvv503, Zero)
new_primQuotInt93(vvv115, Neg(Zero), vvv503) → new_primQuotInt95(vvv115, new_error, vvv503, new_error)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Succ(vvv8720), vvv875, vvv888) → new_primQuotInt79(vvv870, vvv88900, Succ(vvv8720), vvv88900, vvv8720, vvv875)
new_primQuotInt88(vvv115, vvv2200, vvv1160, vvv272) → new_primQuotInt78(vvv115, Succ(vvv2200), vvv1160, vvv272, Succ(vvv2200))
new_primQuotInt95(vvv115, Neg(Succ(vvv47100)), Neg(Succ(vvv31600)), vvv470) → new_primQuotInt118(vvv115, vvv47100, vvv31600, vvv470)

The TRS R consists of the following rules:

new_primRemInt3(vvv46800) → new_error
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_rem1(vvv1030) → new_primRemInt4(vvv1030)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_errorerror([])
new_rem(vvv1160) → new_primRemInt5(vvv1160)
new_rem0(vvv1008) → new_primRemInt3(vvv1008)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Zero) → Zero
new_rem2(vvv47200) → new_primRemInt6(vvv47200)
new_primRemInt6(vvv47200) → new_error
new_fromIntPos(Zero)
new_primRemInt5(vvv2200) → new_error
new_primRemInt4(vvv2200) → new_error

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 9 SCCs with 16 less nodes.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
QDP
                                  ↳ UsableRulesProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt121(vvv1249, Zero, vvv1251, Neg(Succ(vvv125400)), vvv1255) → new_primQuotInt127(vvv1249, vvv1251)
new_primQuotInt95(vvv115, Pos(Succ(vvv47100)), Pos(Zero), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Pos(Zero), Pos(Succ(vvv31600)), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Neg(Succ(vvv47100)), Pos(vvv3160), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt111(vvv1249, vvv1261) → new_primQuotInt117(vvv1249, vvv1261, new_fromInt)
new_primQuotInt119(vvv115, vvv470) → new_primQuotInt120(vvv115, vvv470, new_fromInt)
new_primQuotInt95(vvv115, Pos(Succ(Succ(vvv471000))), Pos(Succ(Succ(vvv316000))), vvv470) → new_primQuotInt118(vvv115, vvv471000, vvv316000, vvv470)
new_primQuotInt118(vvv115, Succ(vvv471000), Succ(vvv316000), vvv470) → new_primQuotInt118(vvv115, vvv471000, vvv316000, vvv470)
new_primQuotInt127(vvv1249, vvv1251) → new_primQuotInt111(vvv1249, new_rem2(vvv1251))
new_primQuotInt120(vvv115, Neg(Succ(vvv47000)), vvv505) → new_primQuotInt121(vvv115, Zero, vvv47000, vvv505, Zero)
new_primQuotInt120(vvv115, Pos(Succ(vvv47000)), vvv505) → new_primQuotInt106(vvv115, Zero, vvv47000, vvv505, Zero)
new_primQuotInt106(vvv1041, Zero, vvv1043, Neg(Succ(vvv104600)), vvv1052) → new_primQuotInt112(vvv1041, vvv1043)
new_primQuotInt95(vvv115, Neg(Zero), Neg(Succ(vvv31600)), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Neg(Succ(vvv47100)), Neg(Zero), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Pos(Succ(vvv47100)), Neg(vvv3160), vvv470) → new_primQuotInt120(vvv115, vvv470, new_fromInt)
new_primQuotInt118(vvv115, Succ(vvv471000), Zero, vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt118(vvv115, Zero, Succ(vvv316000), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt121(vvv1249, Zero, vvv1251, Pos(Succ(vvv125400)), vvv1255) → new_primQuotInt111(vvv1249, new_rem2(vvv1251))
new_primQuotInt112(vvv1041, vvv1043) → new_primQuotInt111(vvv1041, new_rem1(vvv1043))
new_primQuotInt117(vvv1249, vvv1261, vvv1262) → new_primQuotInt95(vvv1249, vvv1261, vvv1262, vvv1261)
new_primQuotInt95(vvv115, Pos(Succ(Zero)), Pos(Succ(Succ(vvv316000))), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Pos(Succ(Succ(vvv471000))), Pos(Succ(Zero)), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt106(vvv1041, Zero, vvv1043, Pos(Succ(vvv104600)), vvv1052) → new_primQuotInt111(vvv1041, new_rem1(vvv1043))
new_primQuotInt95(vvv115, Neg(Zero), Pos(Succ(vvv31600)), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Pos(Zero), Neg(Succ(vvv31600)), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Neg(Succ(vvv47100)), Neg(Succ(vvv31600)), vvv470) → new_primQuotInt118(vvv115, vvv47100, vvv31600, vvv470)

The TRS R consists of the following rules:

new_primRemInt3(vvv46800) → new_error
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_rem1(vvv1030) → new_primRemInt4(vvv1030)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_errorerror([])
new_rem(vvv1160) → new_primRemInt5(vvv1160)
new_rem0(vvv1008) → new_primRemInt3(vvv1008)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Zero) → Zero
new_rem2(vvv47200) → new_primRemInt6(vvv47200)
new_primRemInt6(vvv47200) → new_error
new_fromIntPos(Zero)
new_primRemInt5(vvv2200) → new_error
new_primRemInt4(vvv2200) → new_error

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                  ↳ UsableRulesProof
QDP
                                      ↳ QReductionProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt121(vvv1249, Zero, vvv1251, Neg(Succ(vvv125400)), vvv1255) → new_primQuotInt127(vvv1249, vvv1251)
new_primQuotInt95(vvv115, Pos(Succ(vvv47100)), Pos(Zero), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Pos(Zero), Pos(Succ(vvv31600)), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Neg(Succ(vvv47100)), Pos(vvv3160), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt111(vvv1249, vvv1261) → new_primQuotInt117(vvv1249, vvv1261, new_fromInt)
new_primQuotInt119(vvv115, vvv470) → new_primQuotInt120(vvv115, vvv470, new_fromInt)
new_primQuotInt95(vvv115, Pos(Succ(Succ(vvv471000))), Pos(Succ(Succ(vvv316000))), vvv470) → new_primQuotInt118(vvv115, vvv471000, vvv316000, vvv470)
new_primQuotInt118(vvv115, Succ(vvv471000), Succ(vvv316000), vvv470) → new_primQuotInt118(vvv115, vvv471000, vvv316000, vvv470)
new_primQuotInt127(vvv1249, vvv1251) → new_primQuotInt111(vvv1249, new_rem2(vvv1251))
new_primQuotInt120(vvv115, Neg(Succ(vvv47000)), vvv505) → new_primQuotInt121(vvv115, Zero, vvv47000, vvv505, Zero)
new_primQuotInt120(vvv115, Pos(Succ(vvv47000)), vvv505) → new_primQuotInt106(vvv115, Zero, vvv47000, vvv505, Zero)
new_primQuotInt106(vvv1041, Zero, vvv1043, Neg(Succ(vvv104600)), vvv1052) → new_primQuotInt112(vvv1041, vvv1043)
new_primQuotInt95(vvv115, Neg(Zero), Neg(Succ(vvv31600)), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Neg(Succ(vvv47100)), Neg(Zero), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Pos(Succ(vvv47100)), Neg(vvv3160), vvv470) → new_primQuotInt120(vvv115, vvv470, new_fromInt)
new_primQuotInt118(vvv115, Succ(vvv471000), Zero, vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt118(vvv115, Zero, Succ(vvv316000), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt121(vvv1249, Zero, vvv1251, Pos(Succ(vvv125400)), vvv1255) → new_primQuotInt111(vvv1249, new_rem2(vvv1251))
new_primQuotInt112(vvv1041, vvv1043) → new_primQuotInt111(vvv1041, new_rem1(vvv1043))
new_primQuotInt117(vvv1249, vvv1261, vvv1262) → new_primQuotInt95(vvv1249, vvv1261, vvv1262, vvv1261)
new_primQuotInt95(vvv115, Pos(Succ(Zero)), Pos(Succ(Succ(vvv316000))), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Pos(Succ(Succ(vvv471000))), Pos(Succ(Zero)), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt106(vvv1041, Zero, vvv1043, Pos(Succ(vvv104600)), vvv1052) → new_primQuotInt111(vvv1041, new_rem1(vvv1043))
new_primQuotInt95(vvv115, Neg(Zero), Pos(Succ(vvv31600)), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Pos(Zero), Neg(Succ(vvv31600)), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Neg(Succ(vvv47100)), Neg(Succ(vvv31600)), vvv470) → new_primQuotInt118(vvv115, vvv47100, vvv31600, vvv470)

The TRS R consists of the following rules:

new_rem2(vvv47200) → new_primRemInt6(vvv47200)
new_primRemInt6(vvv47200) → new_error
new_errorerror([])
new_rem1(vvv1030) → new_primRemInt4(vvv1030)
new_primRemInt4(vvv2200) → new_error
new_fromIntPos(Zero)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt5(x0)



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
QDP
                                          ↳ UsableRulesReductionPairsProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt121(vvv1249, Zero, vvv1251, Neg(Succ(vvv125400)), vvv1255) → new_primQuotInt127(vvv1249, vvv1251)
new_primQuotInt95(vvv115, Neg(Succ(vvv47100)), Pos(vvv3160), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Pos(Zero), Pos(Succ(vvv31600)), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Pos(Succ(vvv47100)), Pos(Zero), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt111(vvv1249, vvv1261) → new_primQuotInt117(vvv1249, vvv1261, new_fromInt)
new_primQuotInt119(vvv115, vvv470) → new_primQuotInt120(vvv115, vvv470, new_fromInt)
new_primQuotInt95(vvv115, Pos(Succ(Succ(vvv471000))), Pos(Succ(Succ(vvv316000))), vvv470) → new_primQuotInt118(vvv115, vvv471000, vvv316000, vvv470)
new_primQuotInt118(vvv115, Succ(vvv471000), Succ(vvv316000), vvv470) → new_primQuotInt118(vvv115, vvv471000, vvv316000, vvv470)
new_primQuotInt127(vvv1249, vvv1251) → new_primQuotInt111(vvv1249, new_rem2(vvv1251))
new_primQuotInt120(vvv115, Neg(Succ(vvv47000)), vvv505) → new_primQuotInt121(vvv115, Zero, vvv47000, vvv505, Zero)
new_primQuotInt120(vvv115, Pos(Succ(vvv47000)), vvv505) → new_primQuotInt106(vvv115, Zero, vvv47000, vvv505, Zero)
new_primQuotInt106(vvv1041, Zero, vvv1043, Neg(Succ(vvv104600)), vvv1052) → new_primQuotInt112(vvv1041, vvv1043)
new_primQuotInt95(vvv115, Neg(Zero), Neg(Succ(vvv31600)), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Neg(Succ(vvv47100)), Neg(Zero), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Pos(Succ(vvv47100)), Neg(vvv3160), vvv470) → new_primQuotInt120(vvv115, vvv470, new_fromInt)
new_primQuotInt118(vvv115, Succ(vvv471000), Zero, vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt118(vvv115, Zero, Succ(vvv316000), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt121(vvv1249, Zero, vvv1251, Pos(Succ(vvv125400)), vvv1255) → new_primQuotInt111(vvv1249, new_rem2(vvv1251))
new_primQuotInt112(vvv1041, vvv1043) → new_primQuotInt111(vvv1041, new_rem1(vvv1043))
new_primQuotInt117(vvv1249, vvv1261, vvv1262) → new_primQuotInt95(vvv1249, vvv1261, vvv1262, vvv1261)
new_primQuotInt95(vvv115, Pos(Succ(Zero)), Pos(Succ(Succ(vvv316000))), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Pos(Succ(Succ(vvv471000))), Pos(Succ(Zero)), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt106(vvv1041, Zero, vvv1043, Pos(Succ(vvv104600)), vvv1052) → new_primQuotInt111(vvv1041, new_rem1(vvv1043))
new_primQuotInt95(vvv115, Neg(Zero), Pos(Succ(vvv31600)), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Pos(Zero), Neg(Succ(vvv31600)), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Neg(Succ(vvv47100)), Neg(Succ(vvv31600)), vvv470) → new_primQuotInt118(vvv115, vvv47100, vvv31600, vvv470)

The TRS R consists of the following rules:

new_rem2(vvv47200) → new_primRemInt6(vvv47200)
new_primRemInt6(vvv47200) → new_error
new_errorerror([])
new_rem1(vvv1030) → new_primRemInt4(vvv1030)
new_primRemInt4(vvv2200) → new_error
new_fromIntPos(Zero)

The set Q consists of the following terms:

new_rem2(x0)
new_rem1(x0)
new_primRemInt6(x0)
new_error
new_fromInt
new_primRemInt4(x0)

We have to consider all minimal (P,Q,R)-chains.
By using the usable rules with reduction pair processor [15] with a polynomial ordering [25], all dependency pairs and the corresponding usable rules [17] can be oriented non-strictly. All non-usable rules are removed, and those dependency pairs and usable rules that have been oriented strictly or contain non-usable symbols in their left-hand side are removed as well.

The following dependency pairs can be deleted:

new_primQuotInt121(vvv1249, Zero, vvv1251, Neg(Succ(vvv125400)), vvv1255) → new_primQuotInt127(vvv1249, vvv1251)
new_primQuotInt95(vvv115, Neg(Succ(vvv47100)), Pos(vvv3160), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Pos(Zero), Pos(Succ(vvv31600)), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Pos(Succ(vvv47100)), Pos(Zero), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Pos(Succ(Succ(vvv471000))), Pos(Succ(Succ(vvv316000))), vvv470) → new_primQuotInt118(vvv115, vvv471000, vvv316000, vvv470)
new_primQuotInt118(vvv115, Succ(vvv471000), Succ(vvv316000), vvv470) → new_primQuotInt118(vvv115, vvv471000, vvv316000, vvv470)
new_primQuotInt127(vvv1249, vvv1251) → new_primQuotInt111(vvv1249, new_rem2(vvv1251))
new_primQuotInt120(vvv115, Neg(Succ(vvv47000)), vvv505) → new_primQuotInt121(vvv115, Zero, vvv47000, vvv505, Zero)
new_primQuotInt120(vvv115, Pos(Succ(vvv47000)), vvv505) → new_primQuotInt106(vvv115, Zero, vvv47000, vvv505, Zero)
new_primQuotInt106(vvv1041, Zero, vvv1043, Neg(Succ(vvv104600)), vvv1052) → new_primQuotInt112(vvv1041, vvv1043)
new_primQuotInt95(vvv115, Neg(Zero), Neg(Succ(vvv31600)), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Neg(Succ(vvv47100)), Neg(Zero), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Pos(Succ(vvv47100)), Neg(vvv3160), vvv470) → new_primQuotInt120(vvv115, vvv470, new_fromInt)
new_primQuotInt118(vvv115, Succ(vvv471000), Zero, vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt118(vvv115, Zero, Succ(vvv316000), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt121(vvv1249, Zero, vvv1251, Pos(Succ(vvv125400)), vvv1255) → new_primQuotInt111(vvv1249, new_rem2(vvv1251))
new_primQuotInt112(vvv1041, vvv1043) → new_primQuotInt111(vvv1041, new_rem1(vvv1043))
new_primQuotInt95(vvv115, Pos(Succ(Zero)), Pos(Succ(Succ(vvv316000))), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Pos(Succ(Succ(vvv471000))), Pos(Succ(Zero)), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt106(vvv1041, Zero, vvv1043, Pos(Succ(vvv104600)), vvv1052) → new_primQuotInt111(vvv1041, new_rem1(vvv1043))
new_primQuotInt95(vvv115, Neg(Zero), Pos(Succ(vvv31600)), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Pos(Zero), Neg(Succ(vvv31600)), vvv470) → new_primQuotInt119(vvv115, vvv470)
new_primQuotInt95(vvv115, Neg(Succ(vvv47100)), Neg(Succ(vvv31600)), vvv470) → new_primQuotInt118(vvv115, vvv47100, vvv31600, vvv470)
No rules are removed from R.

Used ordering: POLO with Polynomial interpretation [25]:

POL(Neg(x1)) = 2 + x1   
POL(Pos(x1)) = 2·x1   
POL(Succ(x1)) = 2·x1   
POL(Zero) = 0   
POL([]) = 0   
POL(error(x1)) = 2·x1   
POL(new_error) = 0   
POL(new_fromInt) = 0   
POL(new_primQuotInt106(x1, x2, x3, x4, x5)) = x1 + 2·x2 + 2·x3 + x4 + 2·x5   
POL(new_primQuotInt111(x1, x2)) = x1 + 2·x2   
POL(new_primQuotInt112(x1, x2)) = 2 + x1 + 2·x2   
POL(new_primQuotInt117(x1, x2, x3)) = x1 + 2·x2 + 2·x3   
POL(new_primQuotInt118(x1, x2, x3, x4)) = x1 + 2·x2 + 2·x3 + x4   
POL(new_primQuotInt119(x1, x2)) = x1 + x2   
POL(new_primQuotInt120(x1, x2, x3)) = x1 + x2 + x3   
POL(new_primQuotInt121(x1, x2, x3, x4, x5)) = x1 + 2·x2 + 2·x3 + x4 + 2·x5   
POL(new_primQuotInt127(x1, x2)) = 1 + x1 + 2·x2   
POL(new_primQuotInt95(x1, x2, x3, x4)) = x1 + x2 + x3 + x4   
POL(new_primRemInt4(x1)) = x1   
POL(new_primRemInt6(x1)) = x1   
POL(new_rem1(x1)) = x1   
POL(new_rem2(x1)) = x1   



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ UsableRulesReductionPairsProof
QDP
                                              ↳ DependencyGraphProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt111(vvv1249, vvv1261) → new_primQuotInt117(vvv1249, vvv1261, new_fromInt)
new_primQuotInt119(vvv115, vvv470) → new_primQuotInt120(vvv115, vvv470, new_fromInt)
new_primQuotInt117(vvv1249, vvv1261, vvv1262) → new_primQuotInt95(vvv1249, vvv1261, vvv1262, vvv1261)

The TRS R consists of the following rules:

new_rem2(vvv47200) → new_primRemInt6(vvv47200)
new_primRemInt6(vvv47200) → new_error
new_errorerror([])
new_rem1(vvv1030) → new_primRemInt4(vvv1030)
new_primRemInt4(vvv2200) → new_error
new_fromIntPos(Zero)

The set Q consists of the following terms:

new_rem2(x0)
new_rem1(x0)
new_primRemInt6(x0)
new_error
new_fromInt
new_primRemInt4(x0)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 0 SCCs with 3 less nodes.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
QDP
                                  ↳ UsableRulesProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Zero, vvv1046, vvv1052) → new_primQuotInt106(vvv1041, new_primMinusNatS2(Succ(vvv105300), Zero), Zero, vvv1046, new_primMinusNatS2(Succ(vvv105300), Zero))

The TRS R consists of the following rules:

new_primRemInt3(vvv46800) → new_error
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_rem1(vvv1030) → new_primRemInt4(vvv1030)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_errorerror([])
new_rem(vvv1160) → new_primRemInt5(vvv1160)
new_rem0(vvv1008) → new_primRemInt3(vvv1008)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Zero) → Zero
new_rem2(vvv47200) → new_primRemInt6(vvv47200)
new_primRemInt6(vvv47200) → new_error
new_fromIntPos(Zero)
new_primRemInt5(vvv2200) → new_error
new_primRemInt4(vvv2200) → new_error

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
QDP
                                      ↳ QReductionProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Zero, vvv1046, vvv1052) → new_primQuotInt106(vvv1041, new_primMinusNatS2(Succ(vvv105300), Zero), Zero, vvv1046, new_primMinusNatS2(Succ(vvv105300), Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_error
new_fromInt
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
QDP
                                          ↳ RuleRemovalProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Zero, vvv1046, vvv1052) → new_primQuotInt106(vvv1041, new_primMinusNatS2(Succ(vvv105300), Zero), Zero, vvv1046, new_primMinusNatS2(Succ(vvv105300), Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the rule removal processor [15] with the following polynomial ordering [25], at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Zero, vvv1046, vvv1052) → new_primQuotInt106(vvv1041, new_primMinusNatS2(Succ(vvv105300), Zero), Zero, vvv1046, new_primMinusNatS2(Succ(vvv105300), Zero))


Used ordering: POLO with Polynomial interpretation [25]:

POL(Succ(x1)) = 1 + 2·x1   
POL(Zero) = 0   
POL(new_primMinusNatS2(x1, x2)) = x1 + 2·x2   
POL(new_primQuotInt106(x1, x2, x3, x4, x5)) = x1 + x2 + x3 + x4 + x5   



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ RuleRemovalProof
QDP
                                              ↳ PisEmptyProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
QDP
                                  ↳ UsableRulesProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Zero, vvv1254, vvv1255) → new_primQuotInt121(vvv1249, new_primMinusNatS2(Succ(vvv125600), Zero), Zero, vvv1254, new_primMinusNatS2(Succ(vvv125600), Zero))

The TRS R consists of the following rules:

new_primRemInt3(vvv46800) → new_error
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_rem1(vvv1030) → new_primRemInt4(vvv1030)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_errorerror([])
new_rem(vvv1160) → new_primRemInt5(vvv1160)
new_rem0(vvv1008) → new_primRemInt3(vvv1008)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Zero) → Zero
new_rem2(vvv47200) → new_primRemInt6(vvv47200)
new_primRemInt6(vvv47200) → new_error
new_fromIntPos(Zero)
new_primRemInt5(vvv2200) → new_error
new_primRemInt4(vvv2200) → new_error

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
QDP
                                      ↳ QReductionProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Zero, vvv1254, vvv1255) → new_primQuotInt121(vvv1249, new_primMinusNatS2(Succ(vvv125600), Zero), Zero, vvv1254, new_primMinusNatS2(Succ(vvv125600), Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_error
new_fromInt
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
QDP
                                          ↳ RuleRemovalProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Zero, vvv1254, vvv1255) → new_primQuotInt121(vvv1249, new_primMinusNatS2(Succ(vvv125600), Zero), Zero, vvv1254, new_primMinusNatS2(Succ(vvv125600), Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the rule removal processor [15] with the following polynomial ordering [25], at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Zero, vvv1254, vvv1255) → new_primQuotInt121(vvv1249, new_primMinusNatS2(Succ(vvv125600), Zero), Zero, vvv1254, new_primMinusNatS2(Succ(vvv125600), Zero))


Used ordering: POLO with Polynomial interpretation [25]:

POL(Succ(x1)) = 1 + 2·x1   
POL(Zero) = 0   
POL(new_primMinusNatS2(x1, x2)) = x1 + 2·x2   
POL(new_primQuotInt121(x1, x2, x3, x4, x5)) = x1 + x2 + x3 + x4 + x5   



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ RuleRemovalProof
QDP
                                              ↳ PisEmptyProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
QDP
                                  ↳ UsableRulesProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Zero, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Succ(vvv13260), vvv1327) → new_primQuotInt123(vvv1322, vvv1323, vvv1324, vvv13250, vvv13260, vvv1327)
new_primQuotInt131(vvv1334, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, new_fromInt)
new_primQuotInt130(vvv813, vvv814, vvv817, vvv818) → new_primQuotInt121(vvv813, Succ(vvv814), vvv817, vvv818, Succ(vvv814))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Zero)) → new_primQuotInt128(vvv1322, vvv1324, vvv1323)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), new_fromInt)
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Succ(vvv125400)), vvv1255) → new_primQuotInt125(vvv1249, Zero, vvv125400, Succ(vvv12510), Zero)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Succ(vvv132700))) → new_primQuotInt125(vvv1322, Succ(vvv1323), vvv132700, vvv1324, Succ(vvv1323))
new_primQuotInt126(vvv1249, vvv12510) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, new_fromInt)
new_primQuotInt125(vvv1334, Succ(vvv13350), Succ(vvv13360), vvv1337, vvv1338) → new_primQuotInt125(vvv1334, vvv13350, vvv13360, vvv1337, vvv1338)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Zero, vvv1327) → new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327)
new_primQuotInt125(vvv1334, Zero, Succ(vvv13360), vvv1337, vvv1338) → new_primQuotInt131(vvv1334, vvv1337, vvv1338)
new_primQuotInt124(vvv1334, vvv1337, vvv1338, vvv1339) → new_primQuotInt130(vvv1334, vvv1337, vvv1338, vvv1339)
new_primQuotInt128(vvv1322, vvv1324, vvv1323) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), new_fromInt)
new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Succ(vvv12510), vvv1254, vvv1255) → new_primQuotInt123(vvv1249, vvv125600, Succ(vvv12510), vvv125600, vvv12510, vvv1254)
new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Zero), vvv1255) → new_primQuotInt126(vvv1249, vvv12510)
new_primQuotInt125(vvv1334, Succ(vvv13350), Zero, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, new_fromInt)
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Pos(vvv12540), vvv1255) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, new_fromInt)

The TRS R consists of the following rules:

new_primRemInt3(vvv46800) → new_error
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_rem1(vvv1030) → new_primRemInt4(vvv1030)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_errorerror([])
new_rem(vvv1160) → new_primRemInt5(vvv1160)
new_rem0(vvv1008) → new_primRemInt3(vvv1008)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Zero) → Zero
new_rem2(vvv47200) → new_primRemInt6(vvv47200)
new_primRemInt6(vvv47200) → new_error
new_fromIntPos(Zero)
new_primRemInt5(vvv2200) → new_error
new_primRemInt4(vvv2200) → new_error

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
QDP
                                      ↳ QReductionProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Zero, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Succ(vvv13260), vvv1327) → new_primQuotInt123(vvv1322, vvv1323, vvv1324, vvv13250, vvv13260, vvv1327)
new_primQuotInt131(vvv1334, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, new_fromInt)
new_primQuotInt130(vvv813, vvv814, vvv817, vvv818) → new_primQuotInt121(vvv813, Succ(vvv814), vvv817, vvv818, Succ(vvv814))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Zero)) → new_primQuotInt128(vvv1322, vvv1324, vvv1323)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), new_fromInt)
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Succ(vvv125400)), vvv1255) → new_primQuotInt125(vvv1249, Zero, vvv125400, Succ(vvv12510), Zero)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Succ(vvv132700))) → new_primQuotInt125(vvv1322, Succ(vvv1323), vvv132700, vvv1324, Succ(vvv1323))
new_primQuotInt126(vvv1249, vvv12510) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, new_fromInt)
new_primQuotInt125(vvv1334, Succ(vvv13350), Succ(vvv13360), vvv1337, vvv1338) → new_primQuotInt125(vvv1334, vvv13350, vvv13360, vvv1337, vvv1338)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Zero, vvv1327) → new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327)
new_primQuotInt125(vvv1334, Zero, Succ(vvv13360), vvv1337, vvv1338) → new_primQuotInt131(vvv1334, vvv1337, vvv1338)
new_primQuotInt124(vvv1334, vvv1337, vvv1338, vvv1339) → new_primQuotInt130(vvv1334, vvv1337, vvv1338, vvv1339)
new_primQuotInt128(vvv1322, vvv1324, vvv1323) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), new_fromInt)
new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Succ(vvv12510), vvv1254, vvv1255) → new_primQuotInt123(vvv1249, vvv125600, Succ(vvv12510), vvv125600, vvv12510, vvv1254)
new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Zero), vvv1255) → new_primQuotInt126(vvv1249, vvv12510)
new_primQuotInt125(vvv1334, Succ(vvv13350), Zero, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, new_fromInt)
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Pos(vvv12540), vvv1255) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, new_fromInt)

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_error
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
QDP
                                          ↳ Rewriting
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Zero, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Succ(vvv13260), vvv1327) → new_primQuotInt123(vvv1322, vvv1323, vvv1324, vvv13250, vvv13260, vvv1327)
new_primQuotInt131(vvv1334, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, new_fromInt)
new_primQuotInt130(vvv813, vvv814, vvv817, vvv818) → new_primQuotInt121(vvv813, Succ(vvv814), vvv817, vvv818, Succ(vvv814))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Zero)) → new_primQuotInt128(vvv1322, vvv1324, vvv1323)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), new_fromInt)
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Succ(vvv125400)), vvv1255) → new_primQuotInt125(vvv1249, Zero, vvv125400, Succ(vvv12510), Zero)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Succ(vvv132700))) → new_primQuotInt125(vvv1322, Succ(vvv1323), vvv132700, vvv1324, Succ(vvv1323))
new_primQuotInt126(vvv1249, vvv12510) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, new_fromInt)
new_primQuotInt125(vvv1334, Succ(vvv13350), Succ(vvv13360), vvv1337, vvv1338) → new_primQuotInt125(vvv1334, vvv13350, vvv13360, vvv1337, vvv1338)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Zero, vvv1327) → new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327)
new_primQuotInt125(vvv1334, Zero, Succ(vvv13360), vvv1337, vvv1338) → new_primQuotInt131(vvv1334, vvv1337, vvv1338)
new_primQuotInt124(vvv1334, vvv1337, vvv1338, vvv1339) → new_primQuotInt130(vvv1334, vvv1337, vvv1338, vvv1339)
new_primQuotInt128(vvv1322, vvv1324, vvv1323) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), new_fromInt)
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Zero), vvv1255) → new_primQuotInt126(vvv1249, vvv12510)
new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Succ(vvv12510), vvv1254, vvv1255) → new_primQuotInt123(vvv1249, vvv125600, Succ(vvv12510), vvv125600, vvv12510, vvv1254)
new_primQuotInt125(vvv1334, Succ(vvv13350), Zero, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, new_fromInt)
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Pos(vvv12540), vvv1255) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, new_fromInt)

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt131(vvv1334, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt131(vvv1334, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
QDP
                                              ↳ Rewriting
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Zero, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Succ(vvv13260), vvv1327) → new_primQuotInt123(vvv1322, vvv1323, vvv1324, vvv13250, vvv13260, vvv1327)
new_primQuotInt130(vvv813, vvv814, vvv817, vvv818) → new_primQuotInt121(vvv813, Succ(vvv814), vvv817, vvv818, Succ(vvv814))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), new_fromInt)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Zero)) → new_primQuotInt128(vvv1322, vvv1324, vvv1323)
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Succ(vvv125400)), vvv1255) → new_primQuotInt125(vvv1249, Zero, vvv125400, Succ(vvv12510), Zero)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Succ(vvv132700))) → new_primQuotInt125(vvv1322, Succ(vvv1323), vvv132700, vvv1324, Succ(vvv1323))
new_primQuotInt126(vvv1249, vvv12510) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, new_fromInt)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Zero, vvv1327) → new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327)
new_primQuotInt125(vvv1334, Succ(vvv13350), Succ(vvv13360), vvv1337, vvv1338) → new_primQuotInt125(vvv1334, vvv13350, vvv13360, vvv1337, vvv1338)
new_primQuotInt124(vvv1334, vvv1337, vvv1338, vvv1339) → new_primQuotInt130(vvv1334, vvv1337, vvv1338, vvv1339)
new_primQuotInt125(vvv1334, Zero, Succ(vvv13360), vvv1337, vvv1338) → new_primQuotInt131(vvv1334, vvv1337, vvv1338)
new_primQuotInt128(vvv1322, vvv1324, vvv1323) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), new_fromInt)
new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Succ(vvv12510), vvv1254, vvv1255) → new_primQuotInt123(vvv1249, vvv125600, Succ(vvv12510), vvv125600, vvv12510, vvv1254)
new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Zero), vvv1255) → new_primQuotInt126(vvv1249, vvv12510)
new_primQuotInt125(vvv1334, Succ(vvv13350), Zero, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, new_fromInt)
new_primQuotInt131(vvv1334, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, Pos(Zero))
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Pos(vvv12540), vvv1255) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, new_fromInt)

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
QDP
                                                  ↳ Rewriting
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Zero, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Succ(vvv13260), vvv1327) → new_primQuotInt123(vvv1322, vvv1323, vvv1324, vvv13250, vvv13260, vvv1327)
new_primQuotInt130(vvv813, vvv814, vvv817, vvv818) → new_primQuotInt121(vvv813, Succ(vvv814), vvv817, vvv818, Succ(vvv814))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Zero)) → new_primQuotInt128(vvv1322, vvv1324, vvv1323)
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Succ(vvv125400)), vvv1255) → new_primQuotInt125(vvv1249, Zero, vvv125400, Succ(vvv12510), Zero)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Succ(vvv132700))) → new_primQuotInt125(vvv1322, Succ(vvv1323), vvv132700, vvv1324, Succ(vvv1323))
new_primQuotInt126(vvv1249, vvv12510) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, new_fromInt)
new_primQuotInt125(vvv1334, Succ(vvv13350), Succ(vvv13360), vvv1337, vvv1338) → new_primQuotInt125(vvv1334, vvv13350, vvv13360, vvv1337, vvv1338)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Zero, vvv1327) → new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327)
new_primQuotInt125(vvv1334, Zero, Succ(vvv13360), vvv1337, vvv1338) → new_primQuotInt131(vvv1334, vvv1337, vvv1338)
new_primQuotInt124(vvv1334, vvv1337, vvv1338, vvv1339) → new_primQuotInt130(vvv1334, vvv1337, vvv1338, vvv1339)
new_primQuotInt128(vvv1322, vvv1324, vvv1323) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), new_fromInt)
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Zero), vvv1255) → new_primQuotInt126(vvv1249, vvv12510)
new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Succ(vvv12510), vvv1254, vvv1255) → new_primQuotInt123(vvv1249, vvv125600, Succ(vvv12510), vvv125600, vvv12510, vvv1254)
new_primQuotInt125(vvv1334, Succ(vvv13350), Zero, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, new_fromInt)
new_primQuotInt131(vvv1334, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, Pos(Zero))
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Pos(vvv12540), vvv1255) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, new_fromInt)

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt126(vvv1249, vvv12510) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt126(vvv1249, vvv12510) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
QDP
                                                      ↳ Rewriting
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Zero, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Succ(vvv13260), vvv1327) → new_primQuotInt123(vvv1322, vvv1323, vvv1324, vvv13250, vvv13260, vvv1327)
new_primQuotInt126(vvv1249, vvv12510) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, Pos(Zero))
new_primQuotInt130(vvv813, vvv814, vvv817, vvv818) → new_primQuotInt121(vvv813, Succ(vvv814), vvv817, vvv818, Succ(vvv814))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Zero)) → new_primQuotInt128(vvv1322, vvv1324, vvv1323)
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Succ(vvv125400)), vvv1255) → new_primQuotInt125(vvv1249, Zero, vvv125400, Succ(vvv12510), Zero)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Succ(vvv132700))) → new_primQuotInt125(vvv1322, Succ(vvv1323), vvv132700, vvv1324, Succ(vvv1323))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Zero, vvv1327) → new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327)
new_primQuotInt125(vvv1334, Succ(vvv13350), Succ(vvv13360), vvv1337, vvv1338) → new_primQuotInt125(vvv1334, vvv13350, vvv13360, vvv1337, vvv1338)
new_primQuotInt124(vvv1334, vvv1337, vvv1338, vvv1339) → new_primQuotInt130(vvv1334, vvv1337, vvv1338, vvv1339)
new_primQuotInt125(vvv1334, Zero, Succ(vvv13360), vvv1337, vvv1338) → new_primQuotInt131(vvv1334, vvv1337, vvv1338)
new_primQuotInt128(vvv1322, vvv1324, vvv1323) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), new_fromInt)
new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Succ(vvv12510), vvv1254, vvv1255) → new_primQuotInt123(vvv1249, vvv125600, Succ(vvv12510), vvv125600, vvv12510, vvv1254)
new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Zero), vvv1255) → new_primQuotInt126(vvv1249, vvv12510)
new_primQuotInt125(vvv1334, Succ(vvv13350), Zero, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, new_fromInt)
new_primQuotInt131(vvv1334, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, Pos(Zero))
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Pos(vvv12540), vvv1255) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, new_fromInt)

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt128(vvv1322, vvv1324, vvv1323) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt128(vvv1322, vvv1324, vvv1323) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
QDP
                                                          ↳ Rewriting
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Zero, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Succ(vvv13260), vvv1327) → new_primQuotInt123(vvv1322, vvv1323, vvv1324, vvv13250, vvv13260, vvv1327)
new_primQuotInt126(vvv1249, vvv12510) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, Pos(Zero))
new_primQuotInt130(vvv813, vvv814, vvv817, vvv818) → new_primQuotInt121(vvv813, Succ(vvv814), vvv817, vvv818, Succ(vvv814))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Zero)) → new_primQuotInt128(vvv1322, vvv1324, vvv1323)
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Succ(vvv125400)), vvv1255) → new_primQuotInt125(vvv1249, Zero, vvv125400, Succ(vvv12510), Zero)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Succ(vvv132700))) → new_primQuotInt125(vvv1322, Succ(vvv1323), vvv132700, vvv1324, Succ(vvv1323))
new_primQuotInt125(vvv1334, Succ(vvv13350), Succ(vvv13360), vvv1337, vvv1338) → new_primQuotInt125(vvv1334, vvv13350, vvv13360, vvv1337, vvv1338)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Zero, vvv1327) → new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327)
new_primQuotInt125(vvv1334, Zero, Succ(vvv13360), vvv1337, vvv1338) → new_primQuotInt131(vvv1334, vvv1337, vvv1338)
new_primQuotInt124(vvv1334, vvv1337, vvv1338, vvv1339) → new_primQuotInt130(vvv1334, vvv1337, vvv1338, vvv1339)
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Zero), vvv1255) → new_primQuotInt126(vvv1249, vvv12510)
new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Succ(vvv12510), vvv1254, vvv1255) → new_primQuotInt123(vvv1249, vvv125600, Succ(vvv12510), vvv125600, vvv12510, vvv1254)
new_primQuotInt128(vvv1322, vvv1324, vvv1323) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt125(vvv1334, Succ(vvv13350), Zero, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, new_fromInt)
new_primQuotInt131(vvv1334, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, Pos(Zero))
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Pos(vvv12540), vvv1255) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, new_fromInt)

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt125(vvv1334, Succ(vvv13350), Zero, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt125(vvv1334, Succ(vvv13350), Zero, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
QDP
                                                              ↳ Rewriting
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Zero, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Succ(vvv13260), vvv1327) → new_primQuotInt123(vvv1322, vvv1323, vvv1324, vvv13250, vvv13260, vvv1327)
new_primQuotInt126(vvv1249, vvv12510) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, Pos(Zero))
new_primQuotInt130(vvv813, vvv814, vvv817, vvv818) → new_primQuotInt121(vvv813, Succ(vvv814), vvv817, vvv818, Succ(vvv814))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Zero)) → new_primQuotInt128(vvv1322, vvv1324, vvv1323)
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Succ(vvv125400)), vvv1255) → new_primQuotInt125(vvv1249, Zero, vvv125400, Succ(vvv12510), Zero)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Succ(vvv132700))) → new_primQuotInt125(vvv1322, Succ(vvv1323), vvv132700, vvv1324, Succ(vvv1323))
new_primQuotInt125(vvv1334, Succ(vvv13350), Zero, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Zero, vvv1327) → new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327)
new_primQuotInt125(vvv1334, Succ(vvv13350), Succ(vvv13360), vvv1337, vvv1338) → new_primQuotInt125(vvv1334, vvv13350, vvv13360, vvv1337, vvv1338)
new_primQuotInt124(vvv1334, vvv1337, vvv1338, vvv1339) → new_primQuotInt130(vvv1334, vvv1337, vvv1338, vvv1339)
new_primQuotInt125(vvv1334, Zero, Succ(vvv13360), vvv1337, vvv1338) → new_primQuotInt131(vvv1334, vvv1337, vvv1338)
new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Succ(vvv12510), vvv1254, vvv1255) → new_primQuotInt123(vvv1249, vvv125600, Succ(vvv12510), vvv125600, vvv12510, vvv1254)
new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Zero), vvv1255) → new_primQuotInt126(vvv1249, vvv12510)
new_primQuotInt128(vvv1322, vvv1324, vvv1323) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt131(vvv1334, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, Pos(Zero))
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Pos(vvv12540), vvv1255) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, new_fromInt)

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Pos(vvv12540), vvv1255) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Pos(vvv12540), vvv1255) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
QDP
                                                                  ↳ UsableRulesProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Zero, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Succ(vvv13260), vvv1327) → new_primQuotInt123(vvv1322, vvv1323, vvv1324, vvv13250, vvv13260, vvv1327)
new_primQuotInt126(vvv1249, vvv12510) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, Pos(Zero))
new_primQuotInt130(vvv813, vvv814, vvv817, vvv818) → new_primQuotInt121(vvv813, Succ(vvv814), vvv817, vvv818, Succ(vvv814))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Zero)) → new_primQuotInt128(vvv1322, vvv1324, vvv1323)
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Succ(vvv125400)), vvv1255) → new_primQuotInt125(vvv1249, Zero, vvv125400, Succ(vvv12510), Zero)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Succ(vvv132700))) → new_primQuotInt125(vvv1322, Succ(vvv1323), vvv132700, vvv1324, Succ(vvv1323))
new_primQuotInt125(vvv1334, Succ(vvv13350), Zero, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, Pos(Zero))
new_primQuotInt125(vvv1334, Succ(vvv13350), Succ(vvv13360), vvv1337, vvv1338) → new_primQuotInt125(vvv1334, vvv13350, vvv13360, vvv1337, vvv1338)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Zero, vvv1327) → new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327)
new_primQuotInt125(vvv1334, Zero, Succ(vvv13360), vvv1337, vvv1338) → new_primQuotInt131(vvv1334, vvv1337, vvv1338)
new_primQuotInt124(vvv1334, vvv1337, vvv1338, vvv1339) → new_primQuotInt130(vvv1334, vvv1337, vvv1338, vvv1339)
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Zero), vvv1255) → new_primQuotInt126(vvv1249, vvv12510)
new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Succ(vvv12510), vvv1254, vvv1255) → new_primQuotInt123(vvv1249, vvv125600, Succ(vvv12510), vvv125600, vvv12510, vvv1254)
new_primQuotInt128(vvv1322, vvv1324, vvv1323) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt131(vvv1334, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, Pos(Zero))
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Pos(vvv12540), vvv1255) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, Pos(Zero))

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
QDP
                                                                      ↳ QReductionProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Zero, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Succ(vvv13260), vvv1327) → new_primQuotInt123(vvv1322, vvv1323, vvv1324, vvv13250, vvv13260, vvv1327)
new_primQuotInt126(vvv1249, vvv12510) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, Pos(Zero))
new_primQuotInt130(vvv813, vvv814, vvv817, vvv818) → new_primQuotInt121(vvv813, Succ(vvv814), vvv817, vvv818, Succ(vvv814))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Zero)) → new_primQuotInt128(vvv1322, vvv1324, vvv1323)
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Succ(vvv125400)), vvv1255) → new_primQuotInt125(vvv1249, Zero, vvv125400, Succ(vvv12510), Zero)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Succ(vvv132700))) → new_primQuotInt125(vvv1322, Succ(vvv1323), vvv132700, vvv1324, Succ(vvv1323))
new_primQuotInt125(vvv1334, Succ(vvv13350), Zero, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, Pos(Zero))
new_primQuotInt125(vvv1334, Succ(vvv13350), Succ(vvv13360), vvv1337, vvv1338) → new_primQuotInt125(vvv1334, vvv13350, vvv13360, vvv1337, vvv1338)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Zero, vvv1327) → new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327)
new_primQuotInt125(vvv1334, Zero, Succ(vvv13360), vvv1337, vvv1338) → new_primQuotInt131(vvv1334, vvv1337, vvv1338)
new_primQuotInt124(vvv1334, vvv1337, vvv1338, vvv1339) → new_primQuotInt130(vvv1334, vvv1337, vvv1338, vvv1339)
new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Succ(vvv12510), vvv1254, vvv1255) → new_primQuotInt123(vvv1249, vvv125600, Succ(vvv12510), vvv125600, vvv12510, vvv1254)
new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Zero), vvv1255) → new_primQuotInt126(vvv1249, vvv12510)
new_primQuotInt128(vvv1322, vvv1324, vvv1323) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt131(vvv1334, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, Pos(Zero))
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Pos(vvv12540), vvv1255) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_fromInt



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
QDP
                                                                          ↳ Instantiation
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Zero, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Succ(vvv13260), vvv1327) → new_primQuotInt123(vvv1322, vvv1323, vvv1324, vvv13250, vvv13260, vvv1327)
new_primQuotInt126(vvv1249, vvv12510) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, Pos(Zero))
new_primQuotInt130(vvv813, vvv814, vvv817, vvv818) → new_primQuotInt121(vvv813, Succ(vvv814), vvv817, vvv818, Succ(vvv814))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Zero)) → new_primQuotInt128(vvv1322, vvv1324, vvv1323)
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Succ(vvv125400)), vvv1255) → new_primQuotInt125(vvv1249, Zero, vvv125400, Succ(vvv12510), Zero)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Succ(vvv132700))) → new_primQuotInt125(vvv1322, Succ(vvv1323), vvv132700, vvv1324, Succ(vvv1323))
new_primQuotInt125(vvv1334, Succ(vvv13350), Zero, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, Pos(Zero))
new_primQuotInt125(vvv1334, Succ(vvv13350), Succ(vvv13360), vvv1337, vvv1338) → new_primQuotInt125(vvv1334, vvv13350, vvv13360, vvv1337, vvv1338)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Zero, vvv1327) → new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327)
new_primQuotInt125(vvv1334, Zero, Succ(vvv13360), vvv1337, vvv1338) → new_primQuotInt131(vvv1334, vvv1337, vvv1338)
new_primQuotInt124(vvv1334, vvv1337, vvv1338, vvv1339) → new_primQuotInt130(vvv1334, vvv1337, vvv1338, vvv1339)
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Zero), vvv1255) → new_primQuotInt126(vvv1249, vvv12510)
new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Succ(vvv12510), vvv1254, vvv1255) → new_primQuotInt123(vvv1249, vvv125600, Succ(vvv12510), vvv125600, vvv12510, vvv1254)
new_primQuotInt128(vvv1322, vvv1324, vvv1323) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt131(vvv1334, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, Pos(Zero))
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Pos(vvv12540), vvv1255) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt124(vvv1334, vvv1337, vvv1338, vvv1339) → new_primQuotInt130(vvv1334, vvv1337, vvv1338, vvv1339) we obtained the following new rules:

new_primQuotInt124(z0, z2, z3, Pos(Zero)) → new_primQuotInt130(z0, z2, z3, Pos(Zero))
new_primQuotInt124(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt130(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt124(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt130(z0, z2, Succ(z1), Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
QDP
                                                                              ↳ Instantiation
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Zero, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Succ(vvv13260), vvv1327) → new_primQuotInt123(vvv1322, vvv1323, vvv1324, vvv13250, vvv13260, vvv1327)
new_primQuotInt126(vvv1249, vvv12510) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, Pos(Zero))
new_primQuotInt130(vvv813, vvv814, vvv817, vvv818) → new_primQuotInt121(vvv813, Succ(vvv814), vvv817, vvv818, Succ(vvv814))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Zero)) → new_primQuotInt128(vvv1322, vvv1324, vvv1323)
new_primQuotInt124(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt130(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Succ(vvv125400)), vvv1255) → new_primQuotInt125(vvv1249, Zero, vvv125400, Succ(vvv12510), Zero)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Succ(vvv132700))) → new_primQuotInt125(vvv1322, Succ(vvv1323), vvv132700, vvv1324, Succ(vvv1323))
new_primQuotInt124(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt130(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt125(vvv1334, Succ(vvv13350), Zero, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Zero, vvv1327) → new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327)
new_primQuotInt125(vvv1334, Succ(vvv13350), Succ(vvv13360), vvv1337, vvv1338) → new_primQuotInt125(vvv1334, vvv13350, vvv13360, vvv1337, vvv1338)
new_primQuotInt125(vvv1334, Zero, Succ(vvv13360), vvv1337, vvv1338) → new_primQuotInt131(vvv1334, vvv1337, vvv1338)
new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Succ(vvv12510), vvv1254, vvv1255) → new_primQuotInt123(vvv1249, vvv125600, Succ(vvv12510), vvv125600, vvv12510, vvv1254)
new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Zero), vvv1255) → new_primQuotInt126(vvv1249, vvv12510)
new_primQuotInt128(vvv1322, vvv1324, vvv1323) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt124(z0, z2, z3, Pos(Zero)) → new_primQuotInt130(z0, z2, z3, Pos(Zero))
new_primQuotInt131(vvv1334, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, Pos(Zero))
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Pos(vvv12540), vvv1255) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt130(vvv813, vvv814, vvv817, vvv818) → new_primQuotInt121(vvv813, Succ(vvv814), vvv817, vvv818, Succ(vvv814)) we obtained the following new rules:

new_primQuotInt130(z0, z1, z2, Pos(Zero)) → new_primQuotInt121(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt130(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt121(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt130(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt121(z0, Succ(Succ(z1)), Zero, Pos(Zero), Succ(Succ(z1)))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
QDP
                                                                                  ↳ DependencyGraphProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Zero, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Succ(vvv13260), vvv1327) → new_primQuotInt123(vvv1322, vvv1323, vvv1324, vvv13250, vvv13260, vvv1327)
new_primQuotInt126(vvv1249, vvv12510) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Zero)) → new_primQuotInt128(vvv1322, vvv1324, vvv1323)
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Succ(vvv125400)), vvv1255) → new_primQuotInt125(vvv1249, Zero, vvv125400, Succ(vvv12510), Zero)
new_primQuotInt124(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt130(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Succ(vvv132700))) → new_primQuotInt125(vvv1322, Succ(vvv1323), vvv132700, vvv1324, Succ(vvv1323))
new_primQuotInt125(vvv1334, Succ(vvv13350), Zero, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, Pos(Zero))
new_primQuotInt124(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt130(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt130(z0, z1, z2, Pos(Zero)) → new_primQuotInt121(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt125(vvv1334, Succ(vvv13350), Succ(vvv13360), vvv1337, vvv1338) → new_primQuotInt125(vvv1334, vvv13350, vvv13360, vvv1337, vvv1338)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Zero, vvv1327) → new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327)
new_primQuotInt125(vvv1334, Zero, Succ(vvv13360), vvv1337, vvv1338) → new_primQuotInt131(vvv1334, vvv1337, vvv1338)
new_primQuotInt130(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt121(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Zero), vvv1255) → new_primQuotInt126(vvv1249, vvv12510)
new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Succ(vvv12510), vvv1254, vvv1255) → new_primQuotInt123(vvv1249, vvv125600, Succ(vvv12510), vvv125600, vvv12510, vvv1254)
new_primQuotInt128(vvv1322, vvv1324, vvv1323) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt130(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt121(z0, Succ(Succ(z1)), Zero, Pos(Zero), Succ(Succ(z1)))
new_primQuotInt124(z0, z2, z3, Pos(Zero)) → new_primQuotInt130(z0, z2, z3, Pos(Zero))
new_primQuotInt131(vvv1334, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, Pos(Zero))
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Pos(vvv12540), vvv1255) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
QDP
                                                                                      ↳ QDPOrderProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Zero, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Succ(vvv13260), vvv1327) → new_primQuotInt123(vvv1322, vvv1323, vvv1324, vvv13250, vvv13260, vvv1327)
new_primQuotInt126(vvv1249, vvv12510) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Zero)) → new_primQuotInt128(vvv1322, vvv1324, vvv1323)
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Succ(vvv125400)), vvv1255) → new_primQuotInt125(vvv1249, Zero, vvv125400, Succ(vvv12510), Zero)
new_primQuotInt124(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt130(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Succ(vvv132700))) → new_primQuotInt125(vvv1322, Succ(vvv1323), vvv132700, vvv1324, Succ(vvv1323))
new_primQuotInt125(vvv1334, Succ(vvv13350), Zero, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, Pos(Zero))
new_primQuotInt124(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt130(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt130(z0, z1, z2, Pos(Zero)) → new_primQuotInt121(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt125(vvv1334, Succ(vvv13350), Succ(vvv13360), vvv1337, vvv1338) → new_primQuotInt125(vvv1334, vvv13350, vvv13360, vvv1337, vvv1338)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Zero, vvv1327) → new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327)
new_primQuotInt125(vvv1334, Zero, Succ(vvv13360), vvv1337, vvv1338) → new_primQuotInt131(vvv1334, vvv1337, vvv1338)
new_primQuotInt130(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt121(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Zero), vvv1255) → new_primQuotInt126(vvv1249, vvv12510)
new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Succ(vvv12510), vvv1254, vvv1255) → new_primQuotInt123(vvv1249, vvv125600, Succ(vvv12510), vvv125600, vvv12510, vvv1254)
new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt128(vvv1322, vvv1324, vvv1323) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt124(z0, z2, z3, Pos(Zero)) → new_primQuotInt130(z0, z2, z3, Pos(Zero))
new_primQuotInt131(vvv1334, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, Pos(Zero))
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Pos(vvv12540), vvv1255) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Succ(vvv125400)), vvv1255) → new_primQuotInt125(vvv1249, Zero, vvv125400, Succ(vvv12510), Zero)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Succ(vvv132700))) → new_primQuotInt125(vvv1322, Succ(vvv1323), vvv132700, vvv1324, Succ(vvv1323))
new_primQuotInt125(vvv1334, Succ(vvv13350), Succ(vvv13360), vvv1337, vvv1338) → new_primQuotInt125(vvv1334, vvv13350, vvv13360, vvv1337, vvv1338)
new_primQuotInt131(vvv1334, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, Pos(Zero))
The remaining pairs can at least be oriented weakly.

new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Zero, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Succ(vvv13260), vvv1327) → new_primQuotInt123(vvv1322, vvv1323, vvv1324, vvv13250, vvv13260, vvv1327)
new_primQuotInt126(vvv1249, vvv12510) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Zero)) → new_primQuotInt128(vvv1322, vvv1324, vvv1323)
new_primQuotInt124(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt130(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt125(vvv1334, Succ(vvv13350), Zero, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, Pos(Zero))
new_primQuotInt124(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt130(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt130(z0, z1, z2, Pos(Zero)) → new_primQuotInt121(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Zero, vvv1327) → new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327)
new_primQuotInt125(vvv1334, Zero, Succ(vvv13360), vvv1337, vvv1338) → new_primQuotInt131(vvv1334, vvv1337, vvv1338)
new_primQuotInt130(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt121(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Zero), vvv1255) → new_primQuotInt126(vvv1249, vvv12510)
new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Succ(vvv12510), vvv1254, vvv1255) → new_primQuotInt123(vvv1249, vvv125600, Succ(vvv12510), vvv125600, vvv12510, vvv1254)
new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt128(vvv1322, vvv1324, vvv1323) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt124(z0, z2, z3, Pos(Zero)) → new_primQuotInt130(z0, z2, z3, Pos(Zero))
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Pos(vvv12540), vvv1255) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, Pos(Zero))
Used ordering: Polynomial interpretation [25]:

POL(Neg(x1)) = x1   
POL(Pos(x1)) = 0   
POL(Succ(x1)) = 1 + x1   
POL(Zero) = 0   
POL(new_primMinusNatS2(x1, x2)) = 0   
POL(new_primQuotInt121(x1, x2, x3, x4, x5)) = x4   
POL(new_primQuotInt123(x1, x2, x3, x4, x5, x6)) = x6   
POL(new_primQuotInt124(x1, x2, x3, x4)) = 0   
POL(new_primQuotInt125(x1, x2, x3, x4, x5)) = x3   
POL(new_primQuotInt126(x1, x2)) = 0   
POL(new_primQuotInt128(x1, x2, x3)) = 0   
POL(new_primQuotInt129(x1, x2, x3, x4)) = x4   
POL(new_primQuotInt130(x1, x2, x3, x4)) = 0   
POL(new_primQuotInt131(x1, x2, x3)) = 1   

The following usable rules [17] were oriented: none



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
QDP
                                                                                          ↳ DependencyGraphProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Zero, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Succ(vvv13260), vvv1327) → new_primQuotInt123(vvv1322, vvv1323, vvv1324, vvv13250, vvv13260, vvv1327)
new_primQuotInt126(vvv1249, vvv12510) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Zero)) → new_primQuotInt128(vvv1322, vvv1324, vvv1323)
new_primQuotInt124(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt130(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt125(vvv1334, Succ(vvv13350), Zero, vvv1337, vvv1338) → new_primQuotInt124(vvv1334, vvv1337, vvv1338, Pos(Zero))
new_primQuotInt124(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt130(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt130(z0, z1, z2, Pos(Zero)) → new_primQuotInt121(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Zero, vvv1327) → new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327)
new_primQuotInt125(vvv1334, Zero, Succ(vvv13360), vvv1337, vvv1338) → new_primQuotInt131(vvv1334, vvv1337, vvv1338)
new_primQuotInt130(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt121(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Succ(vvv12510), vvv1254, vvv1255) → new_primQuotInt123(vvv1249, vvv125600, Succ(vvv12510), vvv125600, vvv12510, vvv1254)
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Zero), vvv1255) → new_primQuotInt126(vvv1249, vvv12510)
new_primQuotInt128(vvv1322, vvv1324, vvv1323) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt124(z0, z2, z3, Pos(Zero)) → new_primQuotInt130(z0, z2, z3, Pos(Zero))
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Pos(vvv12540), vvv1255) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 2 less nodes.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ DependencyGraphProof
QDP
                                                                                              ↳ Instantiation
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Zero, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Succ(vvv13260), vvv1327) → new_primQuotInt123(vvv1322, vvv1323, vvv1324, vvv13250, vvv13260, vvv1327)
new_primQuotInt126(vvv1249, vvv12510) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Zero)) → new_primQuotInt128(vvv1322, vvv1324, vvv1323)
new_primQuotInt124(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt130(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt124(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt130(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt130(z0, z1, z2, Pos(Zero)) → new_primQuotInt121(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Zero, vvv1327) → new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327)
new_primQuotInt130(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt121(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Succ(vvv12510), vvv1254, vvv1255) → new_primQuotInt123(vvv1249, vvv125600, Succ(vvv12510), vvv125600, vvv12510, vvv1254)
new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Zero), vvv1255) → new_primQuotInt126(vvv1249, vvv12510)
new_primQuotInt128(vvv1322, vvv1324, vvv1323) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt124(z0, z2, z3, Pos(Zero)) → new_primQuotInt130(z0, z2, z3, Pos(Zero))
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Pos(vvv12540), vvv1255) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt124(z0, z2, z3, Pos(Zero)) → new_primQuotInt130(z0, z2, z3, Pos(Zero)) we obtained the following new rules:

new_primQuotInt124(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt130(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt124(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt130(z0, z1, Succ(z2), Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ DependencyGraphProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
QDP
                                                                                                  ↳ Instantiation
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Zero, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Succ(vvv13260), vvv1327) → new_primQuotInt123(vvv1322, vvv1323, vvv1324, vvv13250, vvv13260, vvv1327)
new_primQuotInt126(vvv1249, vvv12510) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Zero)) → new_primQuotInt128(vvv1322, vvv1324, vvv1323)
new_primQuotInt124(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt130(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt124(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt130(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt130(z0, z1, z2, Pos(Zero)) → new_primQuotInt121(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Zero, vvv1327) → new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327)
new_primQuotInt130(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt121(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Zero), vvv1255) → new_primQuotInt126(vvv1249, vvv12510)
new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Succ(vvv12510), vvv1254, vvv1255) → new_primQuotInt123(vvv1249, vvv125600, Succ(vvv12510), vvv125600, vvv12510, vvv1254)
new_primQuotInt128(vvv1322, vvv1324, vvv1323) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Pos(vvv12540), vvv1255) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt130(z0, z1, z2, Pos(Zero)) → new_primQuotInt121(z0, Succ(z1), z2, Pos(Zero), Succ(z1)) we obtained the following new rules:

new_primQuotInt130(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt121(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt130(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt121(z0, Succ(Succ(z1)), Zero, Pos(Zero), Succ(Succ(z1)))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ DependencyGraphProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
QDP
                                                                                                      ↳ DependencyGraphProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Zero, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Succ(vvv13260), vvv1327) → new_primQuotInt123(vvv1322, vvv1323, vvv1324, vvv13250, vvv13260, vvv1327)
new_primQuotInt126(vvv1249, vvv12510) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Zero)) → new_primQuotInt128(vvv1322, vvv1324, vvv1323)
new_primQuotInt124(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt130(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt124(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt130(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Zero, vvv1327) → new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327)
new_primQuotInt130(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt121(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Succ(vvv12510), vvv1254, vvv1255) → new_primQuotInt123(vvv1249, vvv125600, Succ(vvv12510), vvv125600, vvv12510, vvv1254)
new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Neg(Zero), vvv1255) → new_primQuotInt126(vvv1249, vvv12510)
new_primQuotInt128(vvv1322, vvv1324, vvv1323) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt130(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt121(z0, Succ(Succ(z1)), Zero, Pos(Zero), Succ(Succ(z1)))
new_primQuotInt121(vvv1249, Succ(Zero), Succ(vvv12510), Pos(vvv12540), vvv1255) → new_primQuotInt124(vvv1249, Succ(vvv12510), Zero, Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 5 less nodes.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ DependencyGraphProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
QDP
                                                                                                          ↳ QDPOrderProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Zero, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Zero, vvv1327) → new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Succ(vvv13260), vvv1327) → new_primQuotInt123(vvv1322, vvv1323, vvv1324, vvv13250, vvv13260, vvv1327)
new_primQuotInt130(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt121(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Succ(vvv12510), vvv1254, vvv1255) → new_primQuotInt123(vvv1249, vvv125600, Succ(vvv12510), vvv125600, vvv12510, vvv1254)
new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt128(vvv1322, vvv1324, vvv1323) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Zero)) → new_primQuotInt128(vvv1322, vvv1324, vvv1323)
new_primQuotInt124(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt130(z0, z2, Succ(z1), Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Neg(Zero)) → new_primQuotInt128(vvv1322, vvv1324, vvv1323)
The remaining pairs can at least be oriented weakly.

new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Zero, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Zero, vvv1327) → new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Succ(vvv13260), vvv1327) → new_primQuotInt123(vvv1322, vvv1323, vvv1324, vvv13250, vvv13260, vvv1327)
new_primQuotInt130(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt121(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Succ(vvv12510), vvv1254, vvv1255) → new_primQuotInt123(vvv1249, vvv125600, Succ(vvv12510), vvv125600, vvv12510, vvv1254)
new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt128(vvv1322, vvv1324, vvv1323) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt124(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt130(z0, z2, Succ(z1), Pos(Zero))
Used ordering: Polynomial interpretation [25]:

POL(Neg(x1)) = x1   
POL(Pos(x1)) = 0   
POL(Succ(x1)) = 0   
POL(Zero) = 1   
POL(new_primMinusNatS2(x1, x2)) = 0   
POL(new_primQuotInt121(x1, x2, x3, x4, x5)) = x4   
POL(new_primQuotInt123(x1, x2, x3, x4, x5, x6)) = x6   
POL(new_primQuotInt124(x1, x2, x3, x4)) = 0   
POL(new_primQuotInt128(x1, x2, x3)) = 0   
POL(new_primQuotInt129(x1, x2, x3, x4)) = x4   
POL(new_primQuotInt130(x1, x2, x3, x4)) = 0   

The following usable rules [17] were oriented: none



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ DependencyGraphProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ QDPOrderProof
QDP
                                                                                                              ↳ DependencyGraphProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Zero, vvv1327) → new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Zero, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Succ(vvv13260), vvv1327) → new_primQuotInt123(vvv1322, vvv1323, vvv1324, vvv13250, vvv13260, vvv1327)
new_primQuotInt130(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt121(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Succ(vvv12510), vvv1254, vvv1255) → new_primQuotInt123(vvv1249, vvv125600, Succ(vvv12510), vvv125600, vvv12510, vvv1254)
new_primQuotInt128(vvv1322, vvv1324, vvv1323) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt124(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt130(z0, z2, Succ(z1), Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ DependencyGraphProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ QDPOrderProof
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
QDP
                                                                                                                  ↳ QDPOrderProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Zero, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Zero, vvv1327) → new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Succ(vvv13260), vvv1327) → new_primQuotInt123(vvv1322, vvv1323, vvv1324, vvv13250, vvv13260, vvv1327)
new_primQuotInt130(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt121(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Succ(vvv12510), vvv1254, vvv1255) → new_primQuotInt123(vvv1249, vvv125600, Succ(vvv12510), vvv125600, vvv12510, vvv1254)
new_primQuotInt124(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt130(z0, z2, Succ(z1), Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Zero, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327) → new_primQuotInt121(vvv1322, new_primMinusNatS2(Succ(vvv1323), vvv1324), vvv1324, vvv1327, new_primMinusNatS2(Succ(vvv1323), vvv1324))
The remaining pairs can at least be oriented weakly.

new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Zero, vvv1327) → new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Succ(vvv13260), vvv1327) → new_primQuotInt123(vvv1322, vvv1323, vvv1324, vvv13250, vvv13260, vvv1327)
new_primQuotInt130(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt121(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Succ(vvv12510), vvv1254, vvv1255) → new_primQuotInt123(vvv1249, vvv125600, Succ(vvv12510), vvv125600, vvv12510, vvv1254)
new_primQuotInt124(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt130(z0, z2, Succ(z1), Pos(Zero))
Used ordering: Matrix interpretation [3]:
Non-tuple symbols:
M( Succ(x1) ) =
/1\
\0/
+
/00\
\11/
·x1

M( new_primMinusNatS2(x1, x2) ) =
/1\
\0/
+
/01\
\01/
·x1+
/00\
\00/
·x2

M( Zero ) =
/0\
\0/

M( Pos(x1) ) =
/1\
\0/
+
/00\
\00/
·x1

Tuple symbols:
M( new_primQuotInt123(x1, ..., x6) ) = 1+
[1,1]
·x1+
[1,1]
·x2+
[1,1]
·x3+
[0,0]
·x4+
[0,0]
·x5+
[0,0]
·x6

M( new_primQuotInt129(x1, ..., x4) ) = 1+
[1,1]
·x1+
[1,1]
·x2+
[1,1]
·x3+
[0,0]
·x4

M( new_primQuotInt121(x1, ..., x5) ) = 0+
[1,1]
·x1+
[0,1]
·x2+
[1,1]
·x3+
[0,0]
·x4+
[0,0]
·x5

M( new_primQuotInt124(x1, ..., x4) ) = 0+
[1,1]
·x1+
[1,1]
·x2+
[0,1]
·x3+
[1,0]
·x4

M( new_primQuotInt130(x1, ..., x4) ) = 0+
[1,1]
·x1+
[1,1]
·x2+
[0,1]
·x3+
[1,0]
·x4


Matrix type:
We used a basic matrix type which is not further parametrizeable.


As matrix orders are CE-compatible, we used usable rules w.r.t. argument filtering in the order.
The following usable rules [17] were oriented:

new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ DependencyGraphProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ QDPOrderProof
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ QDPOrderProof
QDP
                                                                                                                      ↳ DependencyGraphProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Zero, vvv1327) → new_primQuotInt129(vvv1322, vvv1323, vvv1324, vvv1327)
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Succ(vvv13260), vvv1327) → new_primQuotInt123(vvv1322, vvv1323, vvv1324, vvv13250, vvv13260, vvv1327)
new_primQuotInt130(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt121(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Succ(vvv12510), vvv1254, vvv1255) → new_primQuotInt123(vvv1249, vvv125600, Succ(vvv12510), vvv125600, vvv12510, vvv1254)
new_primQuotInt124(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt130(z0, z2, Succ(z1), Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ DependencyGraphProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ QDPOrderProof
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ QDPOrderProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
QDP
                                                                                                                          ↳ UsableRulesProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Succ(vvv13260), vvv1327) → new_primQuotInt123(vvv1322, vvv1323, vvv1324, vvv13250, vvv13260, vvv1327)
new_primQuotInt130(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt121(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Succ(vvv12510), vvv1254, vvv1255) → new_primQuotInt123(vvv1249, vvv125600, Succ(vvv12510), vvv125600, vvv12510, vvv1254)
new_primQuotInt124(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt130(z0, z2, Succ(z1), Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ DependencyGraphProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ QDPOrderProof
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ QDPOrderProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ UsableRulesProof
QDP
                                                                                                                              ↳ QReductionProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Succ(vvv13260), vvv1327) → new_primQuotInt123(vvv1322, vvv1323, vvv1324, vvv13250, vvv13260, vvv1327)
new_primQuotInt130(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt121(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Succ(vvv12510), vvv1254, vvv1255) → new_primQuotInt123(vvv1249, vvv125600, Succ(vvv12510), vvv125600, vvv12510, vvv1254)
new_primQuotInt124(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt130(z0, z2, Succ(z1), Pos(Zero))

R is empty.
The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ DependencyGraphProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ QDPOrderProof
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ QDPOrderProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ UsableRulesProof
                                                                                                                            ↳ QDP
                                                                                                                              ↳ QReductionProof
QDP
                                                                                                                                  ↳ Instantiation
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Succ(vvv13260), vvv1327) → new_primQuotInt123(vvv1322, vvv1323, vvv1324, vvv13250, vvv13260, vvv1327)
new_primQuotInt130(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt121(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Succ(vvv12510), vvv1254, vvv1255) → new_primQuotInt123(vvv1249, vvv125600, Succ(vvv12510), vvv125600, vvv12510, vvv1254)
new_primQuotInt124(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt130(z0, z2, Succ(z1), Pos(Zero))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt121(vvv1249, Succ(Succ(vvv125600)), Succ(vvv12510), vvv1254, vvv1255) → new_primQuotInt123(vvv1249, vvv125600, Succ(vvv12510), vvv125600, vvv12510, vvv1254) we obtained the following new rules:

new_primQuotInt121(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt123(z0, x1, Succ(z2), x1, z2, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ DependencyGraphProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ QDPOrderProof
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ QDPOrderProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ UsableRulesProof
                                                                                                                            ↳ QDP
                                                                                                                              ↳ QReductionProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Instantiation
QDP
                                                                                                                                      ↳ NonInfProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Succ(vvv13260), vvv1327) → new_primQuotInt123(vvv1322, vvv1323, vvv1324, vvv13250, vvv13260, vvv1327)
new_primQuotInt130(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt121(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt121(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt123(z0, x1, Succ(z2), x1, z2, Pos(Zero))
new_primQuotInt124(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt130(z0, z2, Succ(z1), Pos(Zero))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The DP Problem is simplified using the Induction Calculus [18] with the following steps:
Note that final constraints are written in bold face.


For Pair new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero)) the following chains were created:




For Pair new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Succ(vvv13260), vvv1327) → new_primQuotInt123(vvv1322, vvv1323, vvv1324, vvv13250, vvv13260, vvv1327) the following chains were created:




For Pair new_primQuotInt130(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt121(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1)) the following chains were created:




For Pair new_primQuotInt124(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt130(z0, z2, Succ(z1), Pos(Zero)) the following chains were created:




For Pair new_primQuotInt121(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt123(z0, x1, Succ(z2), x1, z2, Pos(Zero)) the following chains were created:




To summarize, we get the following constraints P for the following pairs.



The constraints for P> respective Pbound are constructed from P where we just replace every occurence of "t ≥ s" in P by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for Pbound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation [18]:

POL(Pos(x1)) = 1   
POL(Succ(x1)) = 1 + x1   
POL(Zero) = 0   
POL(c) = -1   
POL(new_primQuotInt121(x1, x2, x3, x4, x5)) = 1 + x1 + x3   
POL(new_primQuotInt123(x1, x2, x3, x4, x5, x6)) = 1 + x1 + x2 - x4 + x5 + x6   
POL(new_primQuotInt124(x1, x2, x3, x4)) = 1 + x1 + x3 + x4   
POL(new_primQuotInt130(x1, x2, x3, x4)) = 1 + x1 + x3 + x4   

The following pairs are in P>:

new_primQuotInt130(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt121(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
The following pairs are in Pbound:

new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt130(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt121(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt124(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt130(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt121(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt123(z0, x1, Succ(z2), x1, z2, Pos(Zero))
There are no usable rules

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ DependencyGraphProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ QDPOrderProof
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ QDPOrderProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ UsableRulesProof
                                                                                                                            ↳ QDP
                                                                                                                              ↳ QReductionProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Instantiation
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ NonInfProof
QDP
                                                                                                                                          ↳ DependencyGraphProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt123(vvv1322, vvv1323, vvv1324, Zero, Succ(vvv13260), Pos(vvv13270)) → new_primQuotInt124(vvv1322, vvv1324, Succ(vvv1323), Pos(Zero))
new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Succ(vvv13260), vvv1327) → new_primQuotInt123(vvv1322, vvv1323, vvv1324, vvv13250, vvv13260, vvv1327)
new_primQuotInt121(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt123(z0, x1, Succ(z2), x1, z2, Pos(Zero))
new_primQuotInt124(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt130(z0, z2, Succ(z1), Pos(Zero))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 3 less nodes.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ DependencyGraphProof
                                                                                            ↳ QDP
                                                                                              ↳ Instantiation
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ QDPOrderProof
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ QDPOrderProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ UsableRulesProof
                                                                                                                            ↳ QDP
                                                                                                                              ↳ QReductionProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Instantiation
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ NonInfProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ DependencyGraphProof
QDP
                                                                                                                                              ↳ QDPSizeChangeProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt123(vvv1322, vvv1323, vvv1324, Succ(vvv13250), Succ(vvv13260), vvv1327) → new_primQuotInt123(vvv1322, vvv1323, vvv1324, vvv13250, vvv13260, vvv1327)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
QDP
                                  ↳ UsableRulesProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt84(vvv870, vvv872) → new_primQuotInt83(vvv870, new_rem(vvv872))
new_primQuotInt90(vvv115, Pos(Succ(vvv46900)), Pos(Zero), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt90(vvv115, Pos(Zero), Pos(Succ(vvv28900)), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt91(vvv115, Succ(vvv469000), Zero, vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt91(vvv115, Zero, Succ(vvv289000), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt94(vvv1006, Zero, vvv1008, Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt83(vvv1006, new_rem0(vvv1008))
new_primQuotInt90(vvv115, Pos(Succ(vvv46900)), Neg(vvv2890), vvv468) → new_primQuotInt93(vvv115, vvv468, new_fromInt)
new_primQuotInt90(vvv115, Neg(Succ(vvv46900)), Neg(Succ(vvv28900)), vvv468) → new_primQuotInt91(vvv115, vvv46900, vvv28900, vvv468)
new_primQuotInt93(vvv115, Neg(Succ(vvv46800)), vvv503) → new_primQuotInt94(vvv115, Zero, vvv46800, vvv503, Zero)
new_primQuotInt90(vvv115, Pos(Succ(Zero)), Pos(Succ(Succ(vvv289000))), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt90(vvv115, Pos(Succ(Succ(vvv469000))), Pos(Succ(Zero)), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt83(vvv870, vvv911) → new_primQuotInt89(vvv870, vvv911, new_fromInt)
new_primQuotInt93(vvv115, Pos(Succ(vvv46800)), vvv503) → new_primQuotInt78(vvv115, Zero, vvv46800, vvv503, Zero)
new_primQuotInt101(vvv1006, vvv1008) → new_primQuotInt83(vvv1006, new_rem0(vvv1008))
new_primQuotInt78(vvv870, Zero, vvv872, Neg(Succ(vvv87500)), vvv888) → new_primQuotInt84(vvv870, vvv872)
new_primQuotInt90(vvv115, Neg(Succ(vvv46900)), Pos(vvv2890), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt90(vvv115, Neg(Succ(vvv46900)), Neg(Zero), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt90(vvv115, Neg(Zero), Neg(Succ(vvv28900)), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt78(vvv870, Zero, vvv872, Pos(Succ(vvv87500)), vvv888) → new_primQuotInt83(vvv870, new_rem(vvv872))
new_primQuotInt89(vvv870, vvv911, vvv922) → new_primQuotInt90(vvv870, vvv911, vvv922, vvv911)
new_primQuotInt90(vvv115, Neg(Zero), Pos(Succ(vvv28900)), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt90(vvv115, Pos(Zero), Neg(Succ(vvv28900)), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt94(vvv1006, Zero, vvv1008, Neg(Succ(vvv101100)), vvv1034) → new_primQuotInt101(vvv1006, vvv1008)
new_primQuotInt90(vvv115, Pos(Succ(Succ(vvv469000))), Pos(Succ(Succ(vvv289000))), vvv468) → new_primQuotInt91(vvv115, vvv469000, vvv289000, vvv468)
new_primQuotInt91(vvv115, Succ(vvv469000), Succ(vvv289000), vvv468) → new_primQuotInt91(vvv115, vvv469000, vvv289000, vvv468)
new_primQuotInt92(vvv115, vvv468) → new_primQuotInt93(vvv115, vvv468, new_fromInt)

The TRS R consists of the following rules:

new_primRemInt3(vvv46800) → new_error
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_rem1(vvv1030) → new_primRemInt4(vvv1030)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_errorerror([])
new_rem(vvv1160) → new_primRemInt5(vvv1160)
new_rem0(vvv1008) → new_primRemInt3(vvv1008)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Zero) → Zero
new_rem2(vvv47200) → new_primRemInt6(vvv47200)
new_primRemInt6(vvv47200) → new_error
new_fromIntPos(Zero)
new_primRemInt5(vvv2200) → new_error
new_primRemInt4(vvv2200) → new_error

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
QDP
                                      ↳ QReductionProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt84(vvv870, vvv872) → new_primQuotInt83(vvv870, new_rem(vvv872))
new_primQuotInt90(vvv115, Pos(Succ(vvv46900)), Pos(Zero), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt90(vvv115, Pos(Zero), Pos(Succ(vvv28900)), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt91(vvv115, Succ(vvv469000), Zero, vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt91(vvv115, Zero, Succ(vvv289000), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt94(vvv1006, Zero, vvv1008, Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt83(vvv1006, new_rem0(vvv1008))
new_primQuotInt90(vvv115, Pos(Succ(vvv46900)), Neg(vvv2890), vvv468) → new_primQuotInt93(vvv115, vvv468, new_fromInt)
new_primQuotInt90(vvv115, Neg(Succ(vvv46900)), Neg(Succ(vvv28900)), vvv468) → new_primQuotInt91(vvv115, vvv46900, vvv28900, vvv468)
new_primQuotInt93(vvv115, Neg(Succ(vvv46800)), vvv503) → new_primQuotInt94(vvv115, Zero, vvv46800, vvv503, Zero)
new_primQuotInt90(vvv115, Pos(Succ(Zero)), Pos(Succ(Succ(vvv289000))), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt90(vvv115, Pos(Succ(Succ(vvv469000))), Pos(Succ(Zero)), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt83(vvv870, vvv911) → new_primQuotInt89(vvv870, vvv911, new_fromInt)
new_primQuotInt93(vvv115, Pos(Succ(vvv46800)), vvv503) → new_primQuotInt78(vvv115, Zero, vvv46800, vvv503, Zero)
new_primQuotInt101(vvv1006, vvv1008) → new_primQuotInt83(vvv1006, new_rem0(vvv1008))
new_primQuotInt78(vvv870, Zero, vvv872, Neg(Succ(vvv87500)), vvv888) → new_primQuotInt84(vvv870, vvv872)
new_primQuotInt90(vvv115, Neg(Succ(vvv46900)), Pos(vvv2890), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt90(vvv115, Neg(Succ(vvv46900)), Neg(Zero), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt90(vvv115, Neg(Zero), Neg(Succ(vvv28900)), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt78(vvv870, Zero, vvv872, Pos(Succ(vvv87500)), vvv888) → new_primQuotInt83(vvv870, new_rem(vvv872))
new_primQuotInt89(vvv870, vvv911, vvv922) → new_primQuotInt90(vvv870, vvv911, vvv922, vvv911)
new_primQuotInt90(vvv115, Neg(Zero), Pos(Succ(vvv28900)), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt90(vvv115, Pos(Zero), Neg(Succ(vvv28900)), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt94(vvv1006, Zero, vvv1008, Neg(Succ(vvv101100)), vvv1034) → new_primQuotInt101(vvv1006, vvv1008)
new_primQuotInt90(vvv115, Pos(Succ(Succ(vvv469000))), Pos(Succ(Succ(vvv289000))), vvv468) → new_primQuotInt91(vvv115, vvv469000, vvv289000, vvv468)
new_primQuotInt91(vvv115, Succ(vvv469000), Succ(vvv289000), vvv468) → new_primQuotInt91(vvv115, vvv469000, vvv289000, vvv468)
new_primQuotInt92(vvv115, vvv468) → new_primQuotInt93(vvv115, vvv468, new_fromInt)

The TRS R consists of the following rules:

new_rem0(vvv1008) → new_primRemInt3(vvv1008)
new_primRemInt3(vvv46800) → new_error
new_errorerror([])
new_rem(vvv1160) → new_primRemInt5(vvv1160)
new_primRemInt5(vvv2200) → new_error
new_fromIntPos(Zero)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primMinusNatS2(Succ(x0), Zero)
new_rem2(x0)
new_rem1(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt4(x0)



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
QDP
                                          ↳ UsableRulesReductionPairsProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt90(vvv115, Pos(Zero), Pos(Succ(vvv28900)), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt90(vvv115, Pos(Succ(vvv46900)), Pos(Zero), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt84(vvv870, vvv872) → new_primQuotInt83(vvv870, new_rem(vvv872))
new_primQuotInt91(vvv115, Zero, Succ(vvv289000), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt91(vvv115, Succ(vvv469000), Zero, vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt94(vvv1006, Zero, vvv1008, Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt83(vvv1006, new_rem0(vvv1008))
new_primQuotInt90(vvv115, Pos(Succ(vvv46900)), Neg(vvv2890), vvv468) → new_primQuotInt93(vvv115, vvv468, new_fromInt)
new_primQuotInt90(vvv115, Neg(Succ(vvv46900)), Neg(Succ(vvv28900)), vvv468) → new_primQuotInt91(vvv115, vvv46900, vvv28900, vvv468)
new_primQuotInt93(vvv115, Neg(Succ(vvv46800)), vvv503) → new_primQuotInt94(vvv115, Zero, vvv46800, vvv503, Zero)
new_primQuotInt90(vvv115, Pos(Succ(Succ(vvv469000))), Pos(Succ(Zero)), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt90(vvv115, Pos(Succ(Zero)), Pos(Succ(Succ(vvv289000))), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt83(vvv870, vvv911) → new_primQuotInt89(vvv870, vvv911, new_fromInt)
new_primQuotInt93(vvv115, Pos(Succ(vvv46800)), vvv503) → new_primQuotInt78(vvv115, Zero, vvv46800, vvv503, Zero)
new_primQuotInt101(vvv1006, vvv1008) → new_primQuotInt83(vvv1006, new_rem0(vvv1008))
new_primQuotInt78(vvv870, Zero, vvv872, Neg(Succ(vvv87500)), vvv888) → new_primQuotInt84(vvv870, vvv872)
new_primQuotInt90(vvv115, Neg(Succ(vvv46900)), Pos(vvv2890), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt90(vvv115, Neg(Succ(vvv46900)), Neg(Zero), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt90(vvv115, Neg(Zero), Neg(Succ(vvv28900)), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt78(vvv870, Zero, vvv872, Pos(Succ(vvv87500)), vvv888) → new_primQuotInt83(vvv870, new_rem(vvv872))
new_primQuotInt89(vvv870, vvv911, vvv922) → new_primQuotInt90(vvv870, vvv911, vvv922, vvv911)
new_primQuotInt90(vvv115, Neg(Zero), Pos(Succ(vvv28900)), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt90(vvv115, Pos(Zero), Neg(Succ(vvv28900)), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt94(vvv1006, Zero, vvv1008, Neg(Succ(vvv101100)), vvv1034) → new_primQuotInt101(vvv1006, vvv1008)
new_primQuotInt90(vvv115, Pos(Succ(Succ(vvv469000))), Pos(Succ(Succ(vvv289000))), vvv468) → new_primQuotInt91(vvv115, vvv469000, vvv289000, vvv468)
new_primQuotInt91(vvv115, Succ(vvv469000), Succ(vvv289000), vvv468) → new_primQuotInt91(vvv115, vvv469000, vvv289000, vvv468)
new_primQuotInt92(vvv115, vvv468) → new_primQuotInt93(vvv115, vvv468, new_fromInt)

The TRS R consists of the following rules:

new_rem0(vvv1008) → new_primRemInt3(vvv1008)
new_primRemInt3(vvv46800) → new_error
new_errorerror([])
new_rem(vvv1160) → new_primRemInt5(vvv1160)
new_primRemInt5(vvv2200) → new_error
new_fromIntPos(Zero)

The set Q consists of the following terms:

new_rem0(x0)
new_rem(x0)
new_error
new_fromInt
new_primRemInt3(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
By using the usable rules with reduction pair processor [15] with a polynomial ordering [25], all dependency pairs and the corresponding usable rules [17] can be oriented non-strictly. All non-usable rules are removed, and those dependency pairs and usable rules that have been oriented strictly or contain non-usable symbols in their left-hand side are removed as well.

The following dependency pairs can be deleted:

new_primQuotInt90(vvv115, Pos(Zero), Pos(Succ(vvv28900)), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt90(vvv115, Pos(Succ(vvv46900)), Pos(Zero), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt91(vvv115, Zero, Succ(vvv289000), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt91(vvv115, Succ(vvv469000), Zero, vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt94(vvv1006, Zero, vvv1008, Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt83(vvv1006, new_rem0(vvv1008))
new_primQuotInt90(vvv115, Pos(Succ(vvv46900)), Neg(vvv2890), vvv468) → new_primQuotInt93(vvv115, vvv468, new_fromInt)
new_primQuotInt90(vvv115, Neg(Succ(vvv46900)), Neg(Succ(vvv28900)), vvv468) → new_primQuotInt91(vvv115, vvv46900, vvv28900, vvv468)
new_primQuotInt93(vvv115, Neg(Succ(vvv46800)), vvv503) → new_primQuotInt94(vvv115, Zero, vvv46800, vvv503, Zero)
new_primQuotInt90(vvv115, Pos(Succ(Succ(vvv469000))), Pos(Succ(Zero)), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt90(vvv115, Pos(Succ(Zero)), Pos(Succ(Succ(vvv289000))), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt93(vvv115, Pos(Succ(vvv46800)), vvv503) → new_primQuotInt78(vvv115, Zero, vvv46800, vvv503, Zero)
new_primQuotInt101(vvv1006, vvv1008) → new_primQuotInt83(vvv1006, new_rem0(vvv1008))
new_primQuotInt78(vvv870, Zero, vvv872, Neg(Succ(vvv87500)), vvv888) → new_primQuotInt84(vvv870, vvv872)
new_primQuotInt90(vvv115, Neg(Succ(vvv46900)), Pos(vvv2890), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt90(vvv115, Neg(Succ(vvv46900)), Neg(Zero), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt90(vvv115, Neg(Zero), Neg(Succ(vvv28900)), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt78(vvv870, Zero, vvv872, Pos(Succ(vvv87500)), vvv888) → new_primQuotInt83(vvv870, new_rem(vvv872))
new_primQuotInt90(vvv115, Neg(Zero), Pos(Succ(vvv28900)), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt90(vvv115, Pos(Zero), Neg(Succ(vvv28900)), vvv468) → new_primQuotInt92(vvv115, vvv468)
new_primQuotInt94(vvv1006, Zero, vvv1008, Neg(Succ(vvv101100)), vvv1034) → new_primQuotInt101(vvv1006, vvv1008)
new_primQuotInt90(vvv115, Pos(Succ(Succ(vvv469000))), Pos(Succ(Succ(vvv289000))), vvv468) → new_primQuotInt91(vvv115, vvv469000, vvv289000, vvv468)
new_primQuotInt91(vvv115, Succ(vvv469000), Succ(vvv289000), vvv468) → new_primQuotInt91(vvv115, vvv469000, vvv289000, vvv468)
No rules are removed from R.

Used ordering: POLO with Polynomial interpretation [25]:

POL(Neg(x1)) = 1 + x1   
POL(Pos(x1)) = x1   
POL(Succ(x1)) = 2·x1   
POL(Zero) = 0   
POL([]) = 0   
POL(error(x1)) = 2·x1   
POL(new_error) = 0   
POL(new_fromInt) = 0   
POL(new_primQuotInt101(x1, x2)) = 1 + x1 + 2·x2   
POL(new_primQuotInt78(x1, x2, x3, x4, x5)) = x1 + 2·x2 + 2·x3 + 2·x4 + 2·x5   
POL(new_primQuotInt83(x1, x2)) = x1 + 2·x2   
POL(new_primQuotInt84(x1, x2)) = x1 + 2·x2   
POL(new_primQuotInt89(x1, x2, x3)) = x1 + 2·x2 + 2·x3   
POL(new_primQuotInt90(x1, x2, x3, x4)) = x1 + x2 + x3 + x4   
POL(new_primQuotInt91(x1, x2, x3, x4)) = x1 + 2·x2 + x3 + x4   
POL(new_primQuotInt92(x1, x2)) = x1 + x2   
POL(new_primQuotInt93(x1, x2, x3)) = x1 + x2 + 2·x3   
POL(new_primQuotInt94(x1, x2, x3, x4, x5)) = x1 + x2 + 2·x3 + 2·x4 + x5   
POL(new_primRemInt3(x1)) = x1   
POL(new_primRemInt5(x1)) = x1   
POL(new_rem(x1)) = x1   
POL(new_rem0(x1)) = x1   



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ UsableRulesReductionPairsProof
QDP
                                              ↳ DependencyGraphProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt84(vvv870, vvv872) → new_primQuotInt83(vvv870, new_rem(vvv872))
new_primQuotInt83(vvv870, vvv911) → new_primQuotInt89(vvv870, vvv911, new_fromInt)
new_primQuotInt92(vvv115, vvv468) → new_primQuotInt93(vvv115, vvv468, new_fromInt)
new_primQuotInt89(vvv870, vvv911, vvv922) → new_primQuotInt90(vvv870, vvv911, vvv922, vvv911)

The TRS R consists of the following rules:

new_rem0(vvv1008) → new_primRemInt3(vvv1008)
new_primRemInt3(vvv46800) → new_error
new_errorerror([])
new_rem(vvv1160) → new_primRemInt5(vvv1160)
new_primRemInt5(vvv2200) → new_error
new_fromIntPos(Zero)

The set Q consists of the following terms:

new_rem0(x0)
new_rem(x0)
new_error
new_fromInt
new_primRemInt3(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 0 SCCs with 4 less nodes.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
QDP
                                  ↳ UsableRulesProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Zero, vvv875, vvv888) → new_primQuotInt78(vvv870, new_primMinusNatS2(Succ(vvv88900), Zero), Zero, vvv875, new_primMinusNatS2(Succ(vvv88900), Zero))

The TRS R consists of the following rules:

new_primRemInt3(vvv46800) → new_error
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_rem1(vvv1030) → new_primRemInt4(vvv1030)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_errorerror([])
new_rem(vvv1160) → new_primRemInt5(vvv1160)
new_rem0(vvv1008) → new_primRemInt3(vvv1008)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Zero) → Zero
new_rem2(vvv47200) → new_primRemInt6(vvv47200)
new_primRemInt6(vvv47200) → new_error
new_fromIntPos(Zero)
new_primRemInt5(vvv2200) → new_error
new_primRemInt4(vvv2200) → new_error

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
QDP
                                      ↳ QReductionProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Zero, vvv875, vvv888) → new_primQuotInt78(vvv870, new_primMinusNatS2(Succ(vvv88900), Zero), Zero, vvv875, new_primMinusNatS2(Succ(vvv88900), Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_error
new_fromInt
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
QDP
                                          ↳ RuleRemovalProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Zero, vvv875, vvv888) → new_primQuotInt78(vvv870, new_primMinusNatS2(Succ(vvv88900), Zero), Zero, vvv875, new_primMinusNatS2(Succ(vvv88900), Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the rule removal processor [15] with the following polynomial ordering [25], at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Zero, vvv875, vvv888) → new_primQuotInt78(vvv870, new_primMinusNatS2(Succ(vvv88900), Zero), Zero, vvv875, new_primMinusNatS2(Succ(vvv88900), Zero))


Used ordering: POLO with Polynomial interpretation [25]:

POL(Succ(x1)) = 1 + 2·x1   
POL(Zero) = 0   
POL(new_primMinusNatS2(x1, x2)) = x1 + 2·x2   
POL(new_primQuotInt78(x1, x2, x3, x4, x5)) = x1 + x2 + x3 + x4 + x5   



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ RuleRemovalProof
QDP
                                              ↳ PisEmptyProof
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
QDP
                                  ↳ UsableRulesProof
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Zero, vvv1011, vvv1034) → new_primQuotInt94(vvv1006, new_primMinusNatS2(Succ(vvv103500), Zero), Zero, vvv1011, new_primMinusNatS2(Succ(vvv103500), Zero))

The TRS R consists of the following rules:

new_primRemInt3(vvv46800) → new_error
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_rem1(vvv1030) → new_primRemInt4(vvv1030)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_errorerror([])
new_rem(vvv1160) → new_primRemInt5(vvv1160)
new_rem0(vvv1008) → new_primRemInt3(vvv1008)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Zero) → Zero
new_rem2(vvv47200) → new_primRemInt6(vvv47200)
new_primRemInt6(vvv47200) → new_error
new_fromIntPos(Zero)
new_primRemInt5(vvv2200) → new_error
new_primRemInt4(vvv2200) → new_error

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
QDP
                                      ↳ QReductionProof
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Zero, vvv1011, vvv1034) → new_primQuotInt94(vvv1006, new_primMinusNatS2(Succ(vvv103500), Zero), Zero, vvv1011, new_primMinusNatS2(Succ(vvv103500), Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_error
new_fromInt
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
QDP
                                          ↳ RuleRemovalProof
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Zero, vvv1011, vvv1034) → new_primQuotInt94(vvv1006, new_primMinusNatS2(Succ(vvv103500), Zero), Zero, vvv1011, new_primMinusNatS2(Succ(vvv103500), Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the rule removal processor [15] with the following polynomial ordering [25], at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Zero, vvv1011, vvv1034) → new_primQuotInt94(vvv1006, new_primMinusNatS2(Succ(vvv103500), Zero), Zero, vvv1011, new_primMinusNatS2(Succ(vvv103500), Zero))


Used ordering: POLO with Polynomial interpretation [25]:

POL(Succ(x1)) = 1 + 2·x1   
POL(Zero) = 0   
POL(new_primMinusNatS2(x1, x2)) = x1 + 2·x2   
POL(new_primQuotInt94(x1, x2, x3, x4, x5)) = x1 + x2 + x3 + x4 + x5   



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ RuleRemovalProof
QDP
                                              ↳ PisEmptyProof
                                ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
QDP
                                  ↳ UsableRulesProof
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Zero), vvv1052) → new_primQuotInt110(vvv1041, vvv10430)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Zero)) → new_primQuotInt113(vvv1194, vvv1196, vvv1195)
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, new_fromInt)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt109(vvv1272, Succ(vvv12730), Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt109(vvv1272, vvv12730, vvv12740, vvv1275, vvv1276)
new_primQuotInt115(vvv415, vvv4200, vvv416, vvv481) → new_primQuotInt94(vvv415, Succ(vvv4200), vvv416, vvv481, Succ(vvv4200))
new_primQuotInt108(vvv1272, vvv1275, vvv1276, vvv1298) → new_primQuotInt115(vvv1272, vvv1275, vvv1276, vvv1298)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Succ(vvv119900))) → new_primQuotInt109(vvv1194, Succ(vvv1195), vvv119900, vvv1196, Succ(vvv1195))
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, new_fromInt)
new_primQuotInt105(vvv706, vvv707, vvv710, vvv711) → new_primQuotInt106(vvv706, Succ(vvv707), vvv710, vvv711, Succ(vvv707))
new_primQuotInt113(vvv1194, vvv1196, vvv1195) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), new_fromInt)
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Succ(vvv104600)), vvv1052) → new_primQuotInt109(vvv1041, Zero, vvv104600, Succ(vvv10430), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), new_fromInt)
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, new_fromInt)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Succ(vvv121000))) → new_primQuotInt98(vvv1205, Succ(vvv1206), vvv121000, vvv1207, Succ(vvv1206))
new_primQuotInt109(vvv1272, Succ(vvv12730), Zero, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, new_fromInt)
new_primQuotInt110(vvv1041, vvv10430) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, new_fromInt)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt98(vvv1279, Zero, Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt104(vvv1279, vvv1282, vvv1283)
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Pos(vvv10460), vvv1052) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, new_fromInt)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Neg(vvv12100)) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), new_fromInt)
new_primQuotInt100(vvv1279, vvv1282, vvv1283, vvv1306) → new_primQuotInt105(vvv1279, vvv1282, vvv1283, vvv1306)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt98(vvv1006, Zero, vvv101100, Succ(vvv10080), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Neg(vvv10110), vvv1034) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, new_fromInt)
new_primQuotInt98(vvv1279, Succ(vvv12800), Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt98(vvv1279, vvv12800, vvv12810, vvv1282, vvv1283)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), new_fromInt)
new_primQuotInt116(vvv1272, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, new_fromInt)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt109(vvv1272, Zero, Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt116(vvv1272, vvv1275, vvv1276)

The TRS R consists of the following rules:

new_primRemInt3(vvv46800) → new_error
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_rem1(vvv1030) → new_primRemInt4(vvv1030)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_errorerror([])
new_rem(vvv1160) → new_primRemInt5(vvv1160)
new_rem0(vvv1008) → new_primRemInt3(vvv1008)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Zero) → Zero
new_rem2(vvv47200) → new_primRemInt6(vvv47200)
new_primRemInt6(vvv47200) → new_error
new_fromIntPos(Zero)
new_primRemInt5(vvv2200) → new_error
new_primRemInt4(vvv2200) → new_error

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
QDP
                                      ↳ QReductionProof
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Zero), vvv1052) → new_primQuotInt110(vvv1041, vvv10430)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Zero)) → new_primQuotInt113(vvv1194, vvv1196, vvv1195)
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, new_fromInt)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt109(vvv1272, Succ(vvv12730), Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt109(vvv1272, vvv12730, vvv12740, vvv1275, vvv1276)
new_primQuotInt115(vvv415, vvv4200, vvv416, vvv481) → new_primQuotInt94(vvv415, Succ(vvv4200), vvv416, vvv481, Succ(vvv4200))
new_primQuotInt108(vvv1272, vvv1275, vvv1276, vvv1298) → new_primQuotInt115(vvv1272, vvv1275, vvv1276, vvv1298)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Succ(vvv119900))) → new_primQuotInt109(vvv1194, Succ(vvv1195), vvv119900, vvv1196, Succ(vvv1195))
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, new_fromInt)
new_primQuotInt105(vvv706, vvv707, vvv710, vvv711) → new_primQuotInt106(vvv706, Succ(vvv707), vvv710, vvv711, Succ(vvv707))
new_primQuotInt113(vvv1194, vvv1196, vvv1195) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), new_fromInt)
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Succ(vvv104600)), vvv1052) → new_primQuotInt109(vvv1041, Zero, vvv104600, Succ(vvv10430), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), new_fromInt)
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, new_fromInt)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Succ(vvv121000))) → new_primQuotInt98(vvv1205, Succ(vvv1206), vvv121000, vvv1207, Succ(vvv1206))
new_primQuotInt109(vvv1272, Succ(vvv12730), Zero, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, new_fromInt)
new_primQuotInt110(vvv1041, vvv10430) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, new_fromInt)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt98(vvv1279, Zero, Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt104(vvv1279, vvv1282, vvv1283)
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Pos(vvv10460), vvv1052) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, new_fromInt)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Neg(vvv12100)) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), new_fromInt)
new_primQuotInt100(vvv1279, vvv1282, vvv1283, vvv1306) → new_primQuotInt105(vvv1279, vvv1282, vvv1283, vvv1306)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt98(vvv1006, Zero, vvv101100, Succ(vvv10080), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Neg(vvv10110), vvv1034) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, new_fromInt)
new_primQuotInt98(vvv1279, Succ(vvv12800), Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt98(vvv1279, vvv12800, vvv12810, vvv1282, vvv1283)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), new_fromInt)
new_primQuotInt116(vvv1272, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, new_fromInt)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt109(vvv1272, Zero, Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt116(vvv1272, vvv1275, vvv1276)

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_error
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
QDP
                                          ↳ Rewriting
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Zero), vvv1052) → new_primQuotInt110(vvv1041, vvv10430)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Zero)) → new_primQuotInt113(vvv1194, vvv1196, vvv1195)
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, new_fromInt)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt109(vvv1272, Succ(vvv12730), Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt109(vvv1272, vvv12730, vvv12740, vvv1275, vvv1276)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt108(vvv1272, vvv1275, vvv1276, vvv1298) → new_primQuotInt115(vvv1272, vvv1275, vvv1276, vvv1298)
new_primQuotInt115(vvv415, vvv4200, vvv416, vvv481) → new_primQuotInt94(vvv415, Succ(vvv4200), vvv416, vvv481, Succ(vvv4200))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Succ(vvv119900))) → new_primQuotInt109(vvv1194, Succ(vvv1195), vvv119900, vvv1196, Succ(vvv1195))
new_primQuotInt105(vvv706, vvv707, vvv710, vvv711) → new_primQuotInt106(vvv706, Succ(vvv707), vvv710, vvv711, Succ(vvv707))
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, new_fromInt)
new_primQuotInt113(vvv1194, vvv1196, vvv1195) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), new_fromInt)
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Succ(vvv104600)), vvv1052) → new_primQuotInt109(vvv1041, Zero, vvv104600, Succ(vvv10430), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), new_fromInt)
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, new_fromInt)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Succ(vvv121000))) → new_primQuotInt98(vvv1205, Succ(vvv1206), vvv121000, vvv1207, Succ(vvv1206))
new_primQuotInt109(vvv1272, Succ(vvv12730), Zero, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, new_fromInt)
new_primQuotInt110(vvv1041, vvv10430) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, new_fromInt)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt98(vvv1279, Zero, Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt104(vvv1279, vvv1282, vvv1283)
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Pos(vvv10460), vvv1052) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, new_fromInt)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Neg(vvv12100)) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), new_fromInt)
new_primQuotInt100(vvv1279, vvv1282, vvv1283, vvv1306) → new_primQuotInt105(vvv1279, vvv1282, vvv1283, vvv1306)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt98(vvv1006, Zero, vvv101100, Succ(vvv10080), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Neg(vvv10110), vvv1034) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, new_fromInt)
new_primQuotInt98(vvv1279, Succ(vvv12800), Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt98(vvv1279, vvv12800, vvv12810, vvv1282, vvv1283)
new_primQuotInt116(vvv1272, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, new_fromInt)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), new_fromInt)
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt109(vvv1272, Zero, Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt116(vvv1272, vvv1275, vvv1276)

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
QDP
                                              ↳ Rewriting
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Zero), vvv1052) → new_primQuotInt110(vvv1041, vvv10430)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Zero)) → new_primQuotInt113(vvv1194, vvv1196, vvv1195)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt109(vvv1272, Succ(vvv12730), Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt109(vvv1272, vvv12730, vvv12740, vvv1275, vvv1276)
new_primQuotInt115(vvv415, vvv4200, vvv416, vvv481) → new_primQuotInt94(vvv415, Succ(vvv4200), vvv416, vvv481, Succ(vvv4200))
new_primQuotInt108(vvv1272, vvv1275, vvv1276, vvv1298) → new_primQuotInt115(vvv1272, vvv1275, vvv1276, vvv1298)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Succ(vvv119900))) → new_primQuotInt109(vvv1194, Succ(vvv1195), vvv119900, vvv1196, Succ(vvv1195))
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, new_fromInt)
new_primQuotInt105(vvv706, vvv707, vvv710, vvv711) → new_primQuotInt106(vvv706, Succ(vvv707), vvv710, vvv711, Succ(vvv707))
new_primQuotInt113(vvv1194, vvv1196, vvv1195) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), new_fromInt)
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Succ(vvv104600)), vvv1052) → new_primQuotInt109(vvv1041, Zero, vvv104600, Succ(vvv10430), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), new_fromInt)
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, new_fromInt)
new_primQuotInt109(vvv1272, Succ(vvv12730), Zero, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, new_fromInt)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Succ(vvv121000))) → new_primQuotInt98(vvv1205, Succ(vvv1206), vvv121000, vvv1207, Succ(vvv1206))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt110(vvv1041, vvv10430) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, new_fromInt)
new_primQuotInt98(vvv1279, Zero, Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt104(vvv1279, vvv1282, vvv1283)
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Pos(vvv10460), vvv1052) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, new_fromInt)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Neg(vvv12100)) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), new_fromInt)
new_primQuotInt100(vvv1279, vvv1282, vvv1283, vvv1306) → new_primQuotInt105(vvv1279, vvv1282, vvv1283, vvv1306)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt98(vvv1006, Zero, vvv101100, Succ(vvv10080), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Neg(vvv10110), vvv1034) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, new_fromInt)
new_primQuotInt98(vvv1279, Succ(vvv12800), Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt98(vvv1279, vvv12800, vvv12810, vvv1282, vvv1283)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), new_fromInt)
new_primQuotInt116(vvv1272, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, new_fromInt)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt109(vvv1272, Zero, Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt116(vvv1272, vvv1275, vvv1276)

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
QDP
                                                  ↳ Rewriting
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Zero), vvv1052) → new_primQuotInt110(vvv1041, vvv10430)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Zero)) → new_primQuotInt113(vvv1194, vvv1196, vvv1195)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt109(vvv1272, Succ(vvv12730), Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt109(vvv1272, vvv12730, vvv12740, vvv1275, vvv1276)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt108(vvv1272, vvv1275, vvv1276, vvv1298) → new_primQuotInt115(vvv1272, vvv1275, vvv1276, vvv1298)
new_primQuotInt115(vvv415, vvv4200, vvv416, vvv481) → new_primQuotInt94(vvv415, Succ(vvv4200), vvv416, vvv481, Succ(vvv4200))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Succ(vvv119900))) → new_primQuotInt109(vvv1194, Succ(vvv1195), vvv119900, vvv1196, Succ(vvv1195))
new_primQuotInt105(vvv706, vvv707, vvv710, vvv711) → new_primQuotInt106(vvv706, Succ(vvv707), vvv710, vvv711, Succ(vvv707))
new_primQuotInt113(vvv1194, vvv1196, vvv1195) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), new_fromInt)
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Succ(vvv104600)), vvv1052) → new_primQuotInt109(vvv1041, Zero, vvv104600, Succ(vvv10430), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), new_fromInt)
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, new_fromInt)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Succ(vvv121000))) → new_primQuotInt98(vvv1205, Succ(vvv1206), vvv121000, vvv1207, Succ(vvv1206))
new_primQuotInt109(vvv1272, Succ(vvv12730), Zero, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, new_fromInt)
new_primQuotInt110(vvv1041, vvv10430) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, new_fromInt)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt98(vvv1279, Zero, Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt104(vvv1279, vvv1282, vvv1283)
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Pos(vvv10460), vvv1052) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, new_fromInt)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Neg(vvv12100)) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), new_fromInt)
new_primQuotInt100(vvv1279, vvv1282, vvv1283, vvv1306) → new_primQuotInt105(vvv1279, vvv1282, vvv1283, vvv1306)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt98(vvv1006, Zero, vvv101100, Succ(vvv10080), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Neg(vvv10110), vvv1034) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, new_fromInt)
new_primQuotInt98(vvv1279, Succ(vvv12800), Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt98(vvv1279, vvv12800, vvv12810, vvv1282, vvv1283)
new_primQuotInt116(vvv1272, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, new_fromInt)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), new_fromInt)
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt109(vvv1272, Zero, Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt116(vvv1272, vvv1275, vvv1276)

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt113(vvv1194, vvv1196, vvv1195) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt113(vvv1194, vvv1196, vvv1195) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
QDP
                                                      ↳ Rewriting
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Zero), vvv1052) → new_primQuotInt110(vvv1041, vvv10430)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Zero)) → new_primQuotInt113(vvv1194, vvv1196, vvv1195)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt109(vvv1272, Succ(vvv12730), Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt109(vvv1272, vvv12730, vvv12740, vvv1275, vvv1276)
new_primQuotInt115(vvv415, vvv4200, vvv416, vvv481) → new_primQuotInt94(vvv415, Succ(vvv4200), vvv416, vvv481, Succ(vvv4200))
new_primQuotInt108(vvv1272, vvv1275, vvv1276, vvv1298) → new_primQuotInt115(vvv1272, vvv1275, vvv1276, vvv1298)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Succ(vvv119900))) → new_primQuotInt109(vvv1194, Succ(vvv1195), vvv119900, vvv1196, Succ(vvv1195))
new_primQuotInt105(vvv706, vvv707, vvv710, vvv711) → new_primQuotInt106(vvv706, Succ(vvv707), vvv710, vvv711, Succ(vvv707))
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Succ(vvv104600)), vvv1052) → new_primQuotInt109(vvv1041, Zero, vvv104600, Succ(vvv10430), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), new_fromInt)
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, new_fromInt)
new_primQuotInt109(vvv1272, Succ(vvv12730), Zero, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, new_fromInt)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Succ(vvv121000))) → new_primQuotInt98(vvv1205, Succ(vvv1206), vvv121000, vvv1207, Succ(vvv1206))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt110(vvv1041, vvv10430) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, new_fromInt)
new_primQuotInt98(vvv1279, Zero, Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt104(vvv1279, vvv1282, vvv1283)
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Pos(vvv10460), vvv1052) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, new_fromInt)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Neg(vvv12100)) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), new_fromInt)
new_primQuotInt100(vvv1279, vvv1282, vvv1283, vvv1306) → new_primQuotInt105(vvv1279, vvv1282, vvv1283, vvv1306)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt98(vvv1006, Zero, vvv101100, Succ(vvv10080), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Neg(vvv10110), vvv1034) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, new_fromInt)
new_primQuotInt113(vvv1194, vvv1196, vvv1195) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt98(vvv1279, Succ(vvv12800), Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt98(vvv1279, vvv12800, vvv12810, vvv1282, vvv1283)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), new_fromInt)
new_primQuotInt116(vvv1272, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, new_fromInt)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt109(vvv1272, Zero, Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt116(vvv1272, vvv1275, vvv1276)

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
QDP
                                                          ↳ Rewriting
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Zero), vvv1052) → new_primQuotInt110(vvv1041, vvv10430)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Zero)) → new_primQuotInt113(vvv1194, vvv1196, vvv1195)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt109(vvv1272, Succ(vvv12730), Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt109(vvv1272, vvv12730, vvv12740, vvv1275, vvv1276)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt108(vvv1272, vvv1275, vvv1276, vvv1298) → new_primQuotInt115(vvv1272, vvv1275, vvv1276, vvv1298)
new_primQuotInt115(vvv415, vvv4200, vvv416, vvv481) → new_primQuotInt94(vvv415, Succ(vvv4200), vvv416, vvv481, Succ(vvv4200))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Succ(vvv119900))) → new_primQuotInt109(vvv1194, Succ(vvv1195), vvv119900, vvv1196, Succ(vvv1195))
new_primQuotInt105(vvv706, vvv707, vvv710, vvv711) → new_primQuotInt106(vvv706, Succ(vvv707), vvv710, vvv711, Succ(vvv707))
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Succ(vvv104600)), vvv1052) → new_primQuotInt109(vvv1041, Zero, vvv104600, Succ(vvv10430), Zero)
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, new_fromInt)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Succ(vvv121000))) → new_primQuotInt98(vvv1205, Succ(vvv1206), vvv121000, vvv1207, Succ(vvv1206))
new_primQuotInt109(vvv1272, Succ(vvv12730), Zero, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, new_fromInt)
new_primQuotInt110(vvv1041, vvv10430) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, new_fromInt)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt98(vvv1279, Zero, Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt104(vvv1279, vvv1282, vvv1283)
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Pos(vvv10460), vvv1052) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, new_fromInt)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Neg(vvv12100)) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), new_fromInt)
new_primQuotInt100(vvv1279, vvv1282, vvv1283, vvv1306) → new_primQuotInt105(vvv1279, vvv1282, vvv1283, vvv1306)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt98(vvv1006, Zero, vvv101100, Succ(vvv10080), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Neg(vvv10110), vvv1034) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, new_fromInt)
new_primQuotInt113(vvv1194, vvv1196, vvv1195) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt98(vvv1279, Succ(vvv12800), Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt98(vvv1279, vvv12800, vvv12810, vvv1282, vvv1283)
new_primQuotInt116(vvv1272, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, new_fromInt)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), new_fromInt)
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt109(vvv1272, Zero, Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt116(vvv1272, vvv1275, vvv1276)

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
QDP
                                                              ↳ Rewriting
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Zero), vvv1052) → new_primQuotInt110(vvv1041, vvv10430)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Zero)) → new_primQuotInt113(vvv1194, vvv1196, vvv1195)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt109(vvv1272, Succ(vvv12730), Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt109(vvv1272, vvv12730, vvv12740, vvv1275, vvv1276)
new_primQuotInt115(vvv415, vvv4200, vvv416, vvv481) → new_primQuotInt94(vvv415, Succ(vvv4200), vvv416, vvv481, Succ(vvv4200))
new_primQuotInt108(vvv1272, vvv1275, vvv1276, vvv1298) → new_primQuotInt115(vvv1272, vvv1275, vvv1276, vvv1298)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Succ(vvv119900))) → new_primQuotInt109(vvv1194, Succ(vvv1195), vvv119900, vvv1196, Succ(vvv1195))
new_primQuotInt105(vvv706, vvv707, vvv710, vvv711) → new_primQuotInt106(vvv706, Succ(vvv707), vvv710, vvv711, Succ(vvv707))
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Succ(vvv104600)), vvv1052) → new_primQuotInt109(vvv1041, Zero, vvv104600, Succ(vvv10430), Zero)
new_primQuotInt109(vvv1272, Succ(vvv12730), Zero, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, new_fromInt)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Succ(vvv121000))) → new_primQuotInt98(vvv1205, Succ(vvv1206), vvv121000, vvv1207, Succ(vvv1206))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt110(vvv1041, vvv10430) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, new_fromInt)
new_primQuotInt98(vvv1279, Zero, Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt104(vvv1279, vvv1282, vvv1283)
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Pos(vvv10460), vvv1052) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, new_fromInt)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Neg(vvv12100)) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), new_fromInt)
new_primQuotInt100(vvv1279, vvv1282, vvv1283, vvv1306) → new_primQuotInt105(vvv1279, vvv1282, vvv1283, vvv1306)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt98(vvv1006, Zero, vvv101100, Succ(vvv10080), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Neg(vvv10110), vvv1034) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, new_fromInt)
new_primQuotInt113(vvv1194, vvv1196, vvv1195) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt98(vvv1279, Succ(vvv12800), Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt98(vvv1279, vvv12800, vvv12810, vvv1282, vvv1283)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), new_fromInt)
new_primQuotInt116(vvv1272, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, new_fromInt)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt109(vvv1272, Zero, Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt116(vvv1272, vvv1275, vvv1276)

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt109(vvv1272, Succ(vvv12730), Zero, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt109(vvv1272, Succ(vvv12730), Zero, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
QDP
                                                                  ↳ Rewriting
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Zero), vvv1052) → new_primQuotInt110(vvv1041, vvv10430)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Zero)) → new_primQuotInt113(vvv1194, vvv1196, vvv1195)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt109(vvv1272, Succ(vvv12730), Zero, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))
new_primQuotInt109(vvv1272, Succ(vvv12730), Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt109(vvv1272, vvv12730, vvv12740, vvv1275, vvv1276)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt108(vvv1272, vvv1275, vvv1276, vvv1298) → new_primQuotInt115(vvv1272, vvv1275, vvv1276, vvv1298)
new_primQuotInt115(vvv415, vvv4200, vvv416, vvv481) → new_primQuotInt94(vvv415, Succ(vvv4200), vvv416, vvv481, Succ(vvv4200))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Succ(vvv119900))) → new_primQuotInt109(vvv1194, Succ(vvv1195), vvv119900, vvv1196, Succ(vvv1195))
new_primQuotInt105(vvv706, vvv707, vvv710, vvv711) → new_primQuotInt106(vvv706, Succ(vvv707), vvv710, vvv711, Succ(vvv707))
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Succ(vvv104600)), vvv1052) → new_primQuotInt109(vvv1041, Zero, vvv104600, Succ(vvv10430), Zero)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Succ(vvv121000))) → new_primQuotInt98(vvv1205, Succ(vvv1206), vvv121000, vvv1207, Succ(vvv1206))
new_primQuotInt110(vvv1041, vvv10430) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, new_fromInt)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt98(vvv1279, Zero, Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt104(vvv1279, vvv1282, vvv1283)
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Pos(vvv10460), vvv1052) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, new_fromInt)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Neg(vvv12100)) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), new_fromInt)
new_primQuotInt100(vvv1279, vvv1282, vvv1283, vvv1306) → new_primQuotInt105(vvv1279, vvv1282, vvv1283, vvv1306)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt98(vvv1006, Zero, vvv101100, Succ(vvv10080), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Neg(vvv10110), vvv1034) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, new_fromInt)
new_primQuotInt113(vvv1194, vvv1196, vvv1195) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt98(vvv1279, Succ(vvv12800), Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt98(vvv1279, vvv12800, vvv12810, vvv1282, vvv1283)
new_primQuotInt116(vvv1272, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, new_fromInt)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), new_fromInt)
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt109(vvv1272, Zero, Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt116(vvv1272, vvv1275, vvv1276)

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt110(vvv1041, vvv10430) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt110(vvv1041, vvv10430) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
QDP
                                                                      ↳ Rewriting
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Zero), vvv1052) → new_primQuotInt110(vvv1041, vvv10430)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Zero)) → new_primQuotInt113(vvv1194, vvv1196, vvv1195)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt109(vvv1272, Succ(vvv12730), Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt109(vvv1272, vvv12730, vvv12740, vvv1275, vvv1276)
new_primQuotInt109(vvv1272, Succ(vvv12730), Zero, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))
new_primQuotInt110(vvv1041, vvv10430) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt115(vvv415, vvv4200, vvv416, vvv481) → new_primQuotInt94(vvv415, Succ(vvv4200), vvv416, vvv481, Succ(vvv4200))
new_primQuotInt108(vvv1272, vvv1275, vvv1276, vvv1298) → new_primQuotInt115(vvv1272, vvv1275, vvv1276, vvv1298)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Succ(vvv119900))) → new_primQuotInt109(vvv1194, Succ(vvv1195), vvv119900, vvv1196, Succ(vvv1195))
new_primQuotInt105(vvv706, vvv707, vvv710, vvv711) → new_primQuotInt106(vvv706, Succ(vvv707), vvv710, vvv711, Succ(vvv707))
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Succ(vvv104600)), vvv1052) → new_primQuotInt109(vvv1041, Zero, vvv104600, Succ(vvv10430), Zero)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Succ(vvv121000))) → new_primQuotInt98(vvv1205, Succ(vvv1206), vvv121000, vvv1207, Succ(vvv1206))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt98(vvv1279, Zero, Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt104(vvv1279, vvv1282, vvv1283)
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Pos(vvv10460), vvv1052) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, new_fromInt)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Neg(vvv12100)) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), new_fromInt)
new_primQuotInt100(vvv1279, vvv1282, vvv1283, vvv1306) → new_primQuotInt105(vvv1279, vvv1282, vvv1283, vvv1306)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt98(vvv1006, Zero, vvv101100, Succ(vvv10080), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Neg(vvv10110), vvv1034) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, new_fromInt)
new_primQuotInt113(vvv1194, vvv1196, vvv1195) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt98(vvv1279, Succ(vvv12800), Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt98(vvv1279, vvv12800, vvv12810, vvv1282, vvv1283)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), new_fromInt)
new_primQuotInt116(vvv1272, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, new_fromInt)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt109(vvv1272, Zero, Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt116(vvv1272, vvv1275, vvv1276)

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Pos(vvv10460), vvv1052) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Pos(vvv10460), vvv1052) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
QDP
                                                                          ↳ Rewriting
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Zero), vvv1052) → new_primQuotInt110(vvv1041, vvv10430)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Zero)) → new_primQuotInt113(vvv1194, vvv1196, vvv1195)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt109(vvv1272, Succ(vvv12730), Zero, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))
new_primQuotInt109(vvv1272, Succ(vvv12730), Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt109(vvv1272, vvv12730, vvv12740, vvv1275, vvv1276)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt108(vvv1272, vvv1275, vvv1276, vvv1298) → new_primQuotInt115(vvv1272, vvv1275, vvv1276, vvv1298)
new_primQuotInt115(vvv415, vvv4200, vvv416, vvv481) → new_primQuotInt94(vvv415, Succ(vvv4200), vvv416, vvv481, Succ(vvv4200))
new_primQuotInt110(vvv1041, vvv10430) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Succ(vvv119900))) → new_primQuotInt109(vvv1194, Succ(vvv1195), vvv119900, vvv1196, Succ(vvv1195))
new_primQuotInt105(vvv706, vvv707, vvv710, vvv711) → new_primQuotInt106(vvv706, Succ(vvv707), vvv710, vvv711, Succ(vvv707))
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Succ(vvv104600)), vvv1052) → new_primQuotInt109(vvv1041, Zero, vvv104600, Succ(vvv10430), Zero)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Succ(vvv121000))) → new_primQuotInt98(vvv1205, Succ(vvv1206), vvv121000, vvv1207, Succ(vvv1206))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt98(vvv1279, Zero, Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt104(vvv1279, vvv1282, vvv1283)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Neg(vvv12100)) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), new_fromInt)
new_primQuotInt100(vvv1279, vvv1282, vvv1283, vvv1306) → new_primQuotInt105(vvv1279, vvv1282, vvv1283, vvv1306)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt98(vvv1006, Zero, vvv101100, Succ(vvv10080), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Neg(vvv10110), vvv1034) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, new_fromInt)
new_primQuotInt113(vvv1194, vvv1196, vvv1195) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt98(vvv1279, Succ(vvv12800), Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt98(vvv1279, vvv12800, vvv12810, vvv1282, vvv1283)
new_primQuotInt116(vvv1272, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, new_fromInt)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), new_fromInt)
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Pos(vvv10460), vvv1052) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt109(vvv1272, Zero, Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt116(vvv1272, vvv1275, vvv1276)

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Neg(vvv12100)) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Neg(vvv12100)) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
QDP
                                                                              ↳ Rewriting
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Zero), vvv1052) → new_primQuotInt110(vvv1041, vvv10430)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Zero)) → new_primQuotInt113(vvv1194, vvv1196, vvv1195)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt109(vvv1272, Succ(vvv12730), Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt109(vvv1272, vvv12730, vvv12740, vvv1275, vvv1276)
new_primQuotInt109(vvv1272, Succ(vvv12730), Zero, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))
new_primQuotInt110(vvv1041, vvv10430) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt115(vvv415, vvv4200, vvv416, vvv481) → new_primQuotInt94(vvv415, Succ(vvv4200), vvv416, vvv481, Succ(vvv4200))
new_primQuotInt108(vvv1272, vvv1275, vvv1276, vvv1298) → new_primQuotInt115(vvv1272, vvv1275, vvv1276, vvv1298)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Succ(vvv119900))) → new_primQuotInt109(vvv1194, Succ(vvv1195), vvv119900, vvv1196, Succ(vvv1195))
new_primQuotInt105(vvv706, vvv707, vvv710, vvv711) → new_primQuotInt106(vvv706, Succ(vvv707), vvv710, vvv711, Succ(vvv707))
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Succ(vvv104600)), vvv1052) → new_primQuotInt109(vvv1041, Zero, vvv104600, Succ(vvv10430), Zero)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Succ(vvv121000))) → new_primQuotInt98(vvv1205, Succ(vvv1206), vvv121000, vvv1207, Succ(vvv1206))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt98(vvv1279, Zero, Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt104(vvv1279, vvv1282, vvv1283)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt100(vvv1279, vvv1282, vvv1283, vvv1306) → new_primQuotInt105(vvv1279, vvv1282, vvv1283, vvv1306)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt98(vvv1006, Zero, vvv101100, Succ(vvv10080), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Neg(vvv10110), vvv1034) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, new_fromInt)
new_primQuotInt113(vvv1194, vvv1196, vvv1195) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Neg(vvv12100)) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt98(vvv1279, Succ(vvv12800), Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt98(vvv1279, vvv12800, vvv12810, vvv1282, vvv1283)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), new_fromInt)
new_primQuotInt116(vvv1272, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, new_fromInt)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Pos(vvv10460), vvv1052) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt109(vvv1272, Zero, Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt116(vvv1272, vvv1275, vvv1276)

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Neg(vvv10110), vvv1034) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Neg(vvv10110), vvv1034) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
QDP
                                                                                  ↳ Rewriting
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Zero), vvv1052) → new_primQuotInt110(vvv1041, vvv10430)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Zero)) → new_primQuotInt113(vvv1194, vvv1196, vvv1195)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt109(vvv1272, Succ(vvv12730), Zero, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))
new_primQuotInt109(vvv1272, Succ(vvv12730), Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt109(vvv1272, vvv12730, vvv12740, vvv1275, vvv1276)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt108(vvv1272, vvv1275, vvv1276, vvv1298) → new_primQuotInt115(vvv1272, vvv1275, vvv1276, vvv1298)
new_primQuotInt115(vvv415, vvv4200, vvv416, vvv481) → new_primQuotInt94(vvv415, Succ(vvv4200), vvv416, vvv481, Succ(vvv4200))
new_primQuotInt110(vvv1041, vvv10430) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Succ(vvv119900))) → new_primQuotInt109(vvv1194, Succ(vvv1195), vvv119900, vvv1196, Succ(vvv1195))
new_primQuotInt105(vvv706, vvv707, vvv710, vvv711) → new_primQuotInt106(vvv706, Succ(vvv707), vvv710, vvv711, Succ(vvv707))
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Neg(vvv10110), vvv1034) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Succ(vvv104600)), vvv1052) → new_primQuotInt109(vvv1041, Zero, vvv104600, Succ(vvv10430), Zero)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Succ(vvv121000))) → new_primQuotInt98(vvv1205, Succ(vvv1206), vvv121000, vvv1207, Succ(vvv1206))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt98(vvv1279, Zero, Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt104(vvv1279, vvv1282, vvv1283)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt100(vvv1279, vvv1282, vvv1283, vvv1306) → new_primQuotInt105(vvv1279, vvv1282, vvv1283, vvv1306)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt98(vvv1006, Zero, vvv101100, Succ(vvv10080), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt113(vvv1194, vvv1196, vvv1195) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt98(vvv1279, Succ(vvv12800), Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt98(vvv1279, vvv12800, vvv12810, vvv1282, vvv1283)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Neg(vvv12100)) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt116(vvv1272, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, new_fromInt)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), new_fromInt)
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Pos(vvv10460), vvv1052) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt109(vvv1272, Zero, Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt116(vvv1272, vvv1275, vvv1276)

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
QDP
                                                                                      ↳ Rewriting
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Zero), vvv1052) → new_primQuotInt110(vvv1041, vvv10430)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Zero)) → new_primQuotInt113(vvv1194, vvv1196, vvv1195)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt109(vvv1272, Succ(vvv12730), Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt109(vvv1272, vvv12730, vvv12740, vvv1275, vvv1276)
new_primQuotInt109(vvv1272, Succ(vvv12730), Zero, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))
new_primQuotInt110(vvv1041, vvv10430) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt115(vvv415, vvv4200, vvv416, vvv481) → new_primQuotInt94(vvv415, Succ(vvv4200), vvv416, vvv481, Succ(vvv4200))
new_primQuotInt108(vvv1272, vvv1275, vvv1276, vvv1298) → new_primQuotInt115(vvv1272, vvv1275, vvv1276, vvv1298)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Succ(vvv119900))) → new_primQuotInt109(vvv1194, Succ(vvv1195), vvv119900, vvv1196, Succ(vvv1195))
new_primQuotInt105(vvv706, vvv707, vvv710, vvv711) → new_primQuotInt106(vvv706, Succ(vvv707), vvv710, vvv711, Succ(vvv707))
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Succ(vvv104600)), vvv1052) → new_primQuotInt109(vvv1041, Zero, vvv104600, Succ(vvv10430), Zero)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Neg(vvv10110), vvv1034) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Succ(vvv121000))) → new_primQuotInt98(vvv1205, Succ(vvv1206), vvv121000, vvv1207, Succ(vvv1206))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt98(vvv1279, Zero, Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt104(vvv1279, vvv1282, vvv1283)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt100(vvv1279, vvv1282, vvv1283, vvv1306) → new_primQuotInt105(vvv1279, vvv1282, vvv1283, vvv1306)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt98(vvv1006, Zero, vvv101100, Succ(vvv10080), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt113(vvv1194, vvv1196, vvv1195) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Neg(vvv12100)) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt98(vvv1279, Succ(vvv12800), Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt98(vvv1279, vvv12800, vvv12810, vvv1282, vvv1283)
new_primQuotInt116(vvv1272, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, new_fromInt)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Pos(vvv10460), vvv1052) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt109(vvv1272, Zero, Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt116(vvv1272, vvv1275, vvv1276)

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt116(vvv1272, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt116(vvv1272, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
QDP
                                                                                          ↳ UsableRulesProof
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Zero), vvv1052) → new_primQuotInt110(vvv1041, vvv10430)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Zero)) → new_primQuotInt113(vvv1194, vvv1196, vvv1195)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt109(vvv1272, Succ(vvv12730), Zero, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))
new_primQuotInt109(vvv1272, Succ(vvv12730), Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt109(vvv1272, vvv12730, vvv12740, vvv1275, vvv1276)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt108(vvv1272, vvv1275, vvv1276, vvv1298) → new_primQuotInt115(vvv1272, vvv1275, vvv1276, vvv1298)
new_primQuotInt115(vvv415, vvv4200, vvv416, vvv481) → new_primQuotInt94(vvv415, Succ(vvv4200), vvv416, vvv481, Succ(vvv4200))
new_primQuotInt110(vvv1041, vvv10430) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Succ(vvv119900))) → new_primQuotInt109(vvv1194, Succ(vvv1195), vvv119900, vvv1196, Succ(vvv1195))
new_primQuotInt105(vvv706, vvv707, vvv710, vvv711) → new_primQuotInt106(vvv706, Succ(vvv707), vvv710, vvv711, Succ(vvv707))
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Neg(vvv10110), vvv1034) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Succ(vvv104600)), vvv1052) → new_primQuotInt109(vvv1041, Zero, vvv104600, Succ(vvv10430), Zero)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Succ(vvv121000))) → new_primQuotInt98(vvv1205, Succ(vvv1206), vvv121000, vvv1207, Succ(vvv1206))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt98(vvv1279, Zero, Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt104(vvv1279, vvv1282, vvv1283)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt100(vvv1279, vvv1282, vvv1283, vvv1306) → new_primQuotInt105(vvv1279, vvv1282, vvv1283, vvv1306)
new_primQuotInt116(vvv1272, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt98(vvv1006, Zero, vvv101100, Succ(vvv10080), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt113(vvv1194, vvv1196, vvv1195) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt98(vvv1279, Succ(vvv12800), Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt98(vvv1279, vvv12800, vvv12810, vvv1282, vvv1283)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Neg(vvv12100)) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Pos(vvv10460), vvv1052) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt109(vvv1272, Zero, Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt116(vvv1272, vvv1275, vvv1276)

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
QDP
                                                                                              ↳ QReductionProof
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Zero), vvv1052) → new_primQuotInt110(vvv1041, vvv10430)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Zero)) → new_primQuotInt113(vvv1194, vvv1196, vvv1195)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt109(vvv1272, Succ(vvv12730), Zero, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))
new_primQuotInt109(vvv1272, Succ(vvv12730), Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt109(vvv1272, vvv12730, vvv12740, vvv1275, vvv1276)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt110(vvv1041, vvv10430) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt108(vvv1272, vvv1275, vvv1276, vvv1298) → new_primQuotInt115(vvv1272, vvv1275, vvv1276, vvv1298)
new_primQuotInt115(vvv415, vvv4200, vvv416, vvv481) → new_primQuotInt94(vvv415, Succ(vvv4200), vvv416, vvv481, Succ(vvv4200))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Succ(vvv119900))) → new_primQuotInt109(vvv1194, Succ(vvv1195), vvv119900, vvv1196, Succ(vvv1195))
new_primQuotInt105(vvv706, vvv707, vvv710, vvv711) → new_primQuotInt106(vvv706, Succ(vvv707), vvv710, vvv711, Succ(vvv707))
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Neg(vvv10110), vvv1034) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Succ(vvv104600)), vvv1052) → new_primQuotInt109(vvv1041, Zero, vvv104600, Succ(vvv10430), Zero)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Succ(vvv121000))) → new_primQuotInt98(vvv1205, Succ(vvv1206), vvv121000, vvv1207, Succ(vvv1206))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt98(vvv1279, Zero, Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt104(vvv1279, vvv1282, vvv1283)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt100(vvv1279, vvv1282, vvv1283, vvv1306) → new_primQuotInt105(vvv1279, vvv1282, vvv1283, vvv1306)
new_primQuotInt116(vvv1272, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt98(vvv1006, Zero, vvv101100, Succ(vvv10080), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt113(vvv1194, vvv1196, vvv1195) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Neg(vvv12100)) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt98(vvv1279, Succ(vvv12800), Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt98(vvv1279, vvv12800, vvv12810, vvv1282, vvv1283)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Pos(vvv10460), vvv1052) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt109(vvv1272, Zero, Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt116(vvv1272, vvv1275, vvv1276)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_fromInt



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
QDP
                                                                                                  ↳ Instantiation
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Zero), vvv1052) → new_primQuotInt110(vvv1041, vvv10430)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Zero)) → new_primQuotInt113(vvv1194, vvv1196, vvv1195)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt109(vvv1272, Succ(vvv12730), Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt109(vvv1272, vvv12730, vvv12740, vvv1275, vvv1276)
new_primQuotInt109(vvv1272, Succ(vvv12730), Zero, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))
new_primQuotInt115(vvv415, vvv4200, vvv416, vvv481) → new_primQuotInt94(vvv415, Succ(vvv4200), vvv416, vvv481, Succ(vvv4200))
new_primQuotInt108(vvv1272, vvv1275, vvv1276, vvv1298) → new_primQuotInt115(vvv1272, vvv1275, vvv1276, vvv1298)
new_primQuotInt110(vvv1041, vvv10430) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Succ(vvv119900))) → new_primQuotInt109(vvv1194, Succ(vvv1195), vvv119900, vvv1196, Succ(vvv1195))
new_primQuotInt105(vvv706, vvv707, vvv710, vvv711) → new_primQuotInt106(vvv706, Succ(vvv707), vvv710, vvv711, Succ(vvv707))
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Neg(vvv10110), vvv1034) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Succ(vvv104600)), vvv1052) → new_primQuotInt109(vvv1041, Zero, vvv104600, Succ(vvv10430), Zero)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Succ(vvv121000))) → new_primQuotInt98(vvv1205, Succ(vvv1206), vvv121000, vvv1207, Succ(vvv1206))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt98(vvv1279, Zero, Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt104(vvv1279, vvv1282, vvv1283)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt100(vvv1279, vvv1282, vvv1283, vvv1306) → new_primQuotInt105(vvv1279, vvv1282, vvv1283, vvv1306)
new_primQuotInt116(vvv1272, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt98(vvv1006, Zero, vvv101100, Succ(vvv10080), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt113(vvv1194, vvv1196, vvv1195) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt98(vvv1279, Succ(vvv12800), Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt98(vvv1279, vvv12800, vvv12810, vvv1282, vvv1283)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Neg(vvv12100)) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Pos(vvv10460), vvv1052) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt109(vvv1272, Zero, Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt116(vvv1272, vvv1275, vvv1276)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt108(vvv1272, vvv1275, vvv1276, vvv1298) → new_primQuotInt115(vvv1272, vvv1275, vvv1276, vvv1298) we obtained the following new rules:

new_primQuotInt108(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt115(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt108(z0, z2, z3, Pos(Zero)) → new_primQuotInt115(z0, z2, z3, Pos(Zero))
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
QDP
                                                                                                      ↳ Instantiation
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Zero), vvv1052) → new_primQuotInt110(vvv1041, vvv10430)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Zero)) → new_primQuotInt113(vvv1194, vvv1196, vvv1195)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt109(vvv1272, Succ(vvv12730), Zero, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))
new_primQuotInt109(vvv1272, Succ(vvv12730), Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt109(vvv1272, vvv12730, vvv12740, vvv1275, vvv1276)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt110(vvv1041, vvv10430) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt115(vvv415, vvv4200, vvv416, vvv481) → new_primQuotInt94(vvv415, Succ(vvv4200), vvv416, vvv481, Succ(vvv4200))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Succ(vvv119900))) → new_primQuotInt109(vvv1194, Succ(vvv1195), vvv119900, vvv1196, Succ(vvv1195))
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt105(vvv706, vvv707, vvv710, vvv711) → new_primQuotInt106(vvv706, Succ(vvv707), vvv710, vvv711, Succ(vvv707))
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Succ(vvv104600)), vvv1052) → new_primQuotInt109(vvv1041, Zero, vvv104600, Succ(vvv10430), Zero)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Neg(vvv10110), vvv1034) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Succ(vvv121000))) → new_primQuotInt98(vvv1205, Succ(vvv1206), vvv121000, vvv1207, Succ(vvv1206))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt98(vvv1279, Zero, Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt104(vvv1279, vvv1282, vvv1283)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt100(vvv1279, vvv1282, vvv1283, vvv1306) → new_primQuotInt105(vvv1279, vvv1282, vvv1283, vvv1306)
new_primQuotInt116(vvv1272, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt98(vvv1006, Zero, vvv101100, Succ(vvv10080), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt113(vvv1194, vvv1196, vvv1195) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Neg(vvv12100)) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt98(vvv1279, Succ(vvv12800), Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt98(vvv1279, vvv12800, vvv12810, vvv1282, vvv1283)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt108(z0, z2, z3, Pos(Zero)) → new_primQuotInt115(z0, z2, z3, Pos(Zero))
new_primQuotInt108(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt115(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Pos(vvv10460), vvv1052) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt109(vvv1272, Zero, Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt116(vvv1272, vvv1275, vvv1276)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt115(vvv415, vvv4200, vvv416, vvv481) → new_primQuotInt94(vvv415, Succ(vvv4200), vvv416, vvv481, Succ(vvv4200)) we obtained the following new rules:

new_primQuotInt115(z0, z1, z2, Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt115(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt94(z0, Succ(Succ(z1)), Zero, Pos(Zero), Succ(Succ(z1)))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
QDP
                                                                                                          ↳ DependencyGraphProof
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Zero), vvv1052) → new_primQuotInt110(vvv1041, vvv10430)
new_primQuotInt115(z0, z1, z2, Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Zero)) → new_primQuotInt113(vvv1194, vvv1196, vvv1195)
new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt109(vvv1272, Succ(vvv12730), Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt109(vvv1272, vvv12730, vvv12740, vvv1275, vvv1276)
new_primQuotInt109(vvv1272, Succ(vvv12730), Zero, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))
new_primQuotInt110(vvv1041, vvv10430) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Succ(vvv119900))) → new_primQuotInt109(vvv1194, Succ(vvv1195), vvv119900, vvv1196, Succ(vvv1195))
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt105(vvv706, vvv707, vvv710, vvv711) → new_primQuotInt106(vvv706, Succ(vvv707), vvv710, vvv711, Succ(vvv707))
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Neg(vvv10110), vvv1034) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Succ(vvv104600)), vvv1052) → new_primQuotInt109(vvv1041, Zero, vvv104600, Succ(vvv10430), Zero)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Succ(vvv121000))) → new_primQuotInt98(vvv1205, Succ(vvv1206), vvv121000, vvv1207, Succ(vvv1206))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt98(vvv1279, Zero, Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt104(vvv1279, vvv1282, vvv1283)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt100(vvv1279, vvv1282, vvv1283, vvv1306) → new_primQuotInt105(vvv1279, vvv1282, vvv1283, vvv1306)
new_primQuotInt116(vvv1272, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt98(vvv1006, Zero, vvv101100, Succ(vvv10080), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt113(vvv1194, vvv1196, vvv1195) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt98(vvv1279, Succ(vvv12800), Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt98(vvv1279, vvv12800, vvv12810, vvv1282, vvv1283)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Neg(vvv12100)) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt108(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt115(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt108(z0, z2, z3, Pos(Zero)) → new_primQuotInt115(z0, z2, z3, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Pos(vvv10460), vvv1052) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt115(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt94(z0, Succ(Succ(z1)), Zero, Pos(Zero), Succ(Succ(z1)))
new_primQuotInt109(vvv1272, Zero, Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt116(vvv1272, vvv1275, vvv1276)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
QDP
                                                                                                              ↳ Instantiation
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Zero), vvv1052) → new_primQuotInt110(vvv1041, vvv10430)
new_primQuotInt115(z0, z1, z2, Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Zero)) → new_primQuotInt113(vvv1194, vvv1196, vvv1195)
new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt109(vvv1272, Succ(vvv12730), Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt109(vvv1272, vvv12730, vvv12740, vvv1275, vvv1276)
new_primQuotInt109(vvv1272, Succ(vvv12730), Zero, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))
new_primQuotInt110(vvv1041, vvv10430) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Succ(vvv119900))) → new_primQuotInt109(vvv1194, Succ(vvv1195), vvv119900, vvv1196, Succ(vvv1195))
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt105(vvv706, vvv707, vvv710, vvv711) → new_primQuotInt106(vvv706, Succ(vvv707), vvv710, vvv711, Succ(vvv707))
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Neg(vvv10110), vvv1034) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Succ(vvv104600)), vvv1052) → new_primQuotInt109(vvv1041, Zero, vvv104600, Succ(vvv10430), Zero)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Succ(vvv121000))) → new_primQuotInt98(vvv1205, Succ(vvv1206), vvv121000, vvv1207, Succ(vvv1206))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt98(vvv1279, Zero, Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt104(vvv1279, vvv1282, vvv1283)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt100(vvv1279, vvv1282, vvv1283, vvv1306) → new_primQuotInt105(vvv1279, vvv1282, vvv1283, vvv1306)
new_primQuotInt116(vvv1272, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt98(vvv1006, Zero, vvv101100, Succ(vvv10080), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt113(vvv1194, vvv1196, vvv1195) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Neg(vvv12100)) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt98(vvv1279, Succ(vvv12800), Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt98(vvv1279, vvv12800, vvv12810, vvv1282, vvv1283)
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt108(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt115(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt108(z0, z2, z3, Pos(Zero)) → new_primQuotInt115(z0, z2, z3, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Pos(vvv10460), vvv1052) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt109(vvv1272, Zero, Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt116(vvv1272, vvv1275, vvv1276)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt100(vvv1279, vvv1282, vvv1283, vvv1306) → new_primQuotInt105(vvv1279, vvv1282, vvv1283, vvv1306) we obtained the following new rules:

new_primQuotInt100(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt105(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt100(z0, z1, z2, Pos(Zero)) → new_primQuotInt105(z0, z1, z2, Pos(Zero))
new_primQuotInt100(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
QDP
                                                                                                                  ↳ Instantiation
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Zero), vvv1052) → new_primQuotInt110(vvv1041, vvv10430)
new_primQuotInt115(z0, z1, z2, Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Zero)) → new_primQuotInt113(vvv1194, vvv1196, vvv1195)
new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt109(vvv1272, Succ(vvv12730), Zero, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))
new_primQuotInt109(vvv1272, Succ(vvv12730), Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt109(vvv1272, vvv12730, vvv12740, vvv1275, vvv1276)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt110(vvv1041, vvv10430) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Succ(vvv119900))) → new_primQuotInt109(vvv1194, Succ(vvv1195), vvv119900, vvv1196, Succ(vvv1195))
new_primQuotInt100(z0, z1, z2, Pos(Zero)) → new_primQuotInt105(z0, z1, z2, Pos(Zero))
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt100(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt105(vvv706, vvv707, vvv710, vvv711) → new_primQuotInt106(vvv706, Succ(vvv707), vvv710, vvv711, Succ(vvv707))
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Succ(vvv104600)), vvv1052) → new_primQuotInt109(vvv1041, Zero, vvv104600, Succ(vvv10430), Zero)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Neg(vvv10110), vvv1034) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Succ(vvv121000))) → new_primQuotInt98(vvv1205, Succ(vvv1206), vvv121000, vvv1207, Succ(vvv1206))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt98(vvv1279, Zero, Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt104(vvv1279, vvv1282, vvv1283)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt100(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt105(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt116(vvv1272, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt98(vvv1006, Zero, vvv101100, Succ(vvv10080), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt113(vvv1194, vvv1196, vvv1195) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt98(vvv1279, Succ(vvv12800), Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt98(vvv1279, vvv12800, vvv12810, vvv1282, vvv1283)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Neg(vvv12100)) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt108(z0, z2, z3, Pos(Zero)) → new_primQuotInt115(z0, z2, z3, Pos(Zero))
new_primQuotInt108(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt115(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Pos(vvv10460), vvv1052) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt109(vvv1272, Zero, Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt116(vvv1272, vvv1275, vvv1276)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt105(vvv706, vvv707, vvv710, vvv711) → new_primQuotInt106(vvv706, Succ(vvv707), vvv710, vvv711, Succ(vvv707)) we obtained the following new rules:

new_primQuotInt105(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt106(z0, Succ(Succ(z1)), Zero, Pos(Zero), Succ(Succ(z1)))
new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt105(z0, z1, z2, Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), z2, Pos(Zero), Succ(z1))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Instantiation
QDP
                                                                                                                      ↳ DependencyGraphProof
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Zero), vvv1052) → new_primQuotInt110(vvv1041, vvv10430)
new_primQuotInt105(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt106(z0, Succ(Succ(z1)), Zero, Pos(Zero), Succ(Succ(z1)))
new_primQuotInt115(z0, z1, z2, Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Zero)) → new_primQuotInt113(vvv1194, vvv1196, vvv1195)
new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt109(vvv1272, Succ(vvv12730), Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt109(vvv1272, vvv12730, vvv12740, vvv1275, vvv1276)
new_primQuotInt109(vvv1272, Succ(vvv12730), Zero, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))
new_primQuotInt110(vvv1041, vvv10430) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Succ(vvv119900))) → new_primQuotInt109(vvv1194, Succ(vvv1195), vvv119900, vvv1196, Succ(vvv1195))
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt100(z0, z1, z2, Pos(Zero)) → new_primQuotInt105(z0, z1, z2, Pos(Zero))
new_primQuotInt100(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Neg(vvv10110), vvv1034) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Succ(vvv104600)), vvv1052) → new_primQuotInt109(vvv1041, Zero, vvv104600, Succ(vvv10430), Zero)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Succ(vvv121000))) → new_primQuotInt98(vvv1205, Succ(vvv1206), vvv121000, vvv1207, Succ(vvv1206))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt98(vvv1279, Zero, Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt104(vvv1279, vvv1282, vvv1283)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt100(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt105(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt116(vvv1272, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt98(vvv1006, Zero, vvv101100, Succ(vvv10080), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt113(vvv1194, vvv1196, vvv1195) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Neg(vvv12100)) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt98(vvv1279, Succ(vvv12800), Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt98(vvv1279, vvv12800, vvv12810, vvv1282, vvv1283)
new_primQuotInt105(z0, z1, z2, Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt108(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt115(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt108(z0, z2, z3, Pos(Zero)) → new_primQuotInt115(z0, z2, z3, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Pos(vvv10460), vvv1052) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt109(vvv1272, Zero, Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt116(vvv1272, vvv1275, vvv1276)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Instantiation
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
QDP
                                                                                                                          ↳ QDPOrderProof
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Zero), vvv1052) → new_primQuotInt110(vvv1041, vvv10430)
new_primQuotInt115(z0, z1, z2, Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Zero)) → new_primQuotInt113(vvv1194, vvv1196, vvv1195)
new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt109(vvv1272, Succ(vvv12730), Zero, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt109(vvv1272, Succ(vvv12730), Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt109(vvv1272, vvv12730, vvv12740, vvv1275, vvv1276)
new_primQuotInt110(vvv1041, vvv10430) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Succ(vvv119900))) → new_primQuotInt109(vvv1194, Succ(vvv1195), vvv119900, vvv1196, Succ(vvv1195))
new_primQuotInt100(z0, z1, z2, Pos(Zero)) → new_primQuotInt105(z0, z1, z2, Pos(Zero))
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt100(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Neg(vvv10110), vvv1034) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Succ(vvv104600)), vvv1052) → new_primQuotInt109(vvv1041, Zero, vvv104600, Succ(vvv10430), Zero)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Succ(vvv121000))) → new_primQuotInt98(vvv1205, Succ(vvv1206), vvv121000, vvv1207, Succ(vvv1206))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt98(vvv1279, Zero, Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt104(vvv1279, vvv1282, vvv1283)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt100(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt105(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt116(vvv1272, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt98(vvv1006, Zero, vvv101100, Succ(vvv10080), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt113(vvv1194, vvv1196, vvv1195) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Neg(vvv12100)) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt98(vvv1279, Succ(vvv12800), Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt98(vvv1279, vvv12800, vvv12810, vvv1282, vvv1283)
new_primQuotInt105(z0, z1, z2, Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt108(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt115(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt108(z0, z2, z3, Pos(Zero)) → new_primQuotInt115(z0, z2, z3, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Pos(vvv10460), vvv1052) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt109(vvv1272, Zero, Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt116(vvv1272, vvv1275, vvv1276)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Neg(vvv10110), vvv1034) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Neg(vvv12100)) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
The remaining pairs can at least be oriented weakly.

new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Zero), vvv1052) → new_primQuotInt110(vvv1041, vvv10430)
new_primQuotInt115(z0, z1, z2, Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Zero)) → new_primQuotInt113(vvv1194, vvv1196, vvv1195)
new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt109(vvv1272, Succ(vvv12730), Zero, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt109(vvv1272, Succ(vvv12730), Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt109(vvv1272, vvv12730, vvv12740, vvv1275, vvv1276)
new_primQuotInt110(vvv1041, vvv10430) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Succ(vvv119900))) → new_primQuotInt109(vvv1194, Succ(vvv1195), vvv119900, vvv1196, Succ(vvv1195))
new_primQuotInt100(z0, z1, z2, Pos(Zero)) → new_primQuotInt105(z0, z1, z2, Pos(Zero))
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt100(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Succ(vvv104600)), vvv1052) → new_primQuotInt109(vvv1041, Zero, vvv104600, Succ(vvv10430), Zero)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Succ(vvv121000))) → new_primQuotInt98(vvv1205, Succ(vvv1206), vvv121000, vvv1207, Succ(vvv1206))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt98(vvv1279, Zero, Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt104(vvv1279, vvv1282, vvv1283)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt100(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt105(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt116(vvv1272, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt98(vvv1006, Zero, vvv101100, Succ(vvv10080), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt113(vvv1194, vvv1196, vvv1195) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt98(vvv1279, Succ(vvv12800), Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt98(vvv1279, vvv12800, vvv12810, vvv1282, vvv1283)
new_primQuotInt105(z0, z1, z2, Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt108(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt115(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt108(z0, z2, z3, Pos(Zero)) → new_primQuotInt115(z0, z2, z3, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Pos(vvv10460), vvv1052) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt109(vvv1272, Zero, Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt116(vvv1272, vvv1275, vvv1276)
Used ordering: Polynomial interpretation [25]:

POL(Neg(x1)) = 1   
POL(Pos(x1)) = 0   
POL(Succ(x1)) = 0   
POL(Zero) = 0   
POL(new_primMinusNatS2(x1, x2)) = 0   
POL(new_primQuotInt100(x1, x2, x3, x4)) = 0   
POL(new_primQuotInt102(x1, x2, x3)) = 0   
POL(new_primQuotInt103(x1, x2, x3, x4)) = x4   
POL(new_primQuotInt104(x1, x2, x3)) = 0   
POL(new_primQuotInt105(x1, x2, x3, x4)) = 0   
POL(new_primQuotInt106(x1, x2, x3, x4, x5)) = 0   
POL(new_primQuotInt107(x1, x2, x3, x4, x5, x6)) = x3   
POL(new_primQuotInt108(x1, x2, x3, x4)) = x3   
POL(new_primQuotInt109(x1, x2, x3, x4, x5)) = x5   
POL(new_primQuotInt110(x1, x2)) = 0   
POL(new_primQuotInt113(x1, x2, x3)) = 0   
POL(new_primQuotInt114(x1, x2, x3, x4)) = 0   
POL(new_primQuotInt115(x1, x2, x3, x4)) = x3   
POL(new_primQuotInt116(x1, x2, x3)) = x3   
POL(new_primQuotInt94(x1, x2, x3, x4, x5)) = x4   
POL(new_primQuotInt97(x1, x2, x3, x4, x5, x6)) = x6   
POL(new_primQuotInt98(x1, x2, x3, x4, x5)) = 0   
POL(new_primQuotInt99(x1, x2)) = 0   

The following usable rules [17] were oriented: none



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Instantiation
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ QDPOrderProof
QDP
                                                                                                                              ↳ QDPOrderProof
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Zero), vvv1052) → new_primQuotInt110(vvv1041, vvv10430)
new_primQuotInt115(z0, z1, z2, Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Zero)) → new_primQuotInt113(vvv1194, vvv1196, vvv1195)
new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt109(vvv1272, Succ(vvv12730), Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt109(vvv1272, vvv12730, vvv12740, vvv1275, vvv1276)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt109(vvv1272, Succ(vvv12730), Zero, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))
new_primQuotInt110(vvv1041, vvv10430) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Succ(vvv119900))) → new_primQuotInt109(vvv1194, Succ(vvv1195), vvv119900, vvv1196, Succ(vvv1195))
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt100(z0, z1, z2, Pos(Zero)) → new_primQuotInt105(z0, z1, z2, Pos(Zero))
new_primQuotInt100(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Succ(vvv104600)), vvv1052) → new_primQuotInt109(vvv1041, Zero, vvv104600, Succ(vvv10430), Zero)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Succ(vvv121000))) → new_primQuotInt98(vvv1205, Succ(vvv1206), vvv121000, vvv1207, Succ(vvv1206))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt98(vvv1279, Zero, Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt104(vvv1279, vvv1282, vvv1283)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt100(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt105(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt116(vvv1272, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt98(vvv1006, Zero, vvv101100, Succ(vvv10080), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt113(vvv1194, vvv1196, vvv1195) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt98(vvv1279, Succ(vvv12800), Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt98(vvv1279, vvv12800, vvv12810, vvv1282, vvv1283)
new_primQuotInt105(z0, z1, z2, Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt108(z0, z2, z3, Pos(Zero)) → new_primQuotInt115(z0, z2, z3, Pos(Zero))
new_primQuotInt108(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt115(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Pos(vvv10460), vvv1052) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt109(vvv1272, Zero, Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt116(vvv1272, vvv1275, vvv1276)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_primQuotInt110(vvv1041, vvv10430) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Succ(vvv119900))) → new_primQuotInt109(vvv1194, Succ(vvv1195), vvv119900, vvv1196, Succ(vvv1195))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Succ(vvv104600)), vvv1052) → new_primQuotInt109(vvv1041, Zero, vvv104600, Succ(vvv10430), Zero)
new_primQuotInt113(vvv1194, vvv1196, vvv1195) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
The remaining pairs can at least be oriented weakly.

new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Zero), vvv1052) → new_primQuotInt110(vvv1041, vvv10430)
new_primQuotInt115(z0, z1, z2, Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Zero)) → new_primQuotInt113(vvv1194, vvv1196, vvv1195)
new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt109(vvv1272, Succ(vvv12730), Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt109(vvv1272, vvv12730, vvv12740, vvv1275, vvv1276)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt109(vvv1272, Succ(vvv12730), Zero, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt100(z0, z1, z2, Pos(Zero)) → new_primQuotInt105(z0, z1, z2, Pos(Zero))
new_primQuotInt100(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Succ(vvv121000))) → new_primQuotInt98(vvv1205, Succ(vvv1206), vvv121000, vvv1207, Succ(vvv1206))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt98(vvv1279, Zero, Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt104(vvv1279, vvv1282, vvv1283)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt100(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt105(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt116(vvv1272, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt98(vvv1006, Zero, vvv101100, Succ(vvv10080), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt98(vvv1279, Succ(vvv12800), Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt98(vvv1279, vvv12800, vvv12810, vvv1282, vvv1283)
new_primQuotInt105(z0, z1, z2, Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt108(z0, z2, z3, Pos(Zero)) → new_primQuotInt115(z0, z2, z3, Pos(Zero))
new_primQuotInt108(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt115(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Pos(vvv10460), vvv1052) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt109(vvv1272, Zero, Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt116(vvv1272, vvv1275, vvv1276)
Used ordering: Polynomial interpretation [25]:

POL(Neg(x1)) = 1   
POL(Pos(x1)) = 0   
POL(Succ(x1)) = 0   
POL(Zero) = 0   
POL(new_primMinusNatS2(x1, x2)) = 1   
POL(new_primQuotInt100(x1, x2, x3, x4)) = 0   
POL(new_primQuotInt102(x1, x2, x3)) = 0   
POL(new_primQuotInt103(x1, x2, x3, x4)) = 0   
POL(new_primQuotInt104(x1, x2, x3)) = 0   
POL(new_primQuotInt105(x1, x2, x3, x4)) = 0   
POL(new_primQuotInt106(x1, x2, x3, x4, x5)) = x4   
POL(new_primQuotInt107(x1, x2, x3, x4, x5, x6)) = x3 + x6   
POL(new_primQuotInt108(x1, x2, x3, x4)) = 0   
POL(new_primQuotInt109(x1, x2, x3, x4, x5)) = x4 + x5   
POL(new_primQuotInt110(x1, x2)) = 1   
POL(new_primQuotInt113(x1, x2, x3)) = 1   
POL(new_primQuotInt114(x1, x2, x3, x4)) = x3 + x4   
POL(new_primQuotInt115(x1, x2, x3, x4)) = 0   
POL(new_primQuotInt116(x1, x2, x3)) = x3   
POL(new_primQuotInt94(x1, x2, x3, x4, x5)) = 0   
POL(new_primQuotInt97(x1, x2, x3, x4, x5, x6)) = 0   
POL(new_primQuotInt98(x1, x2, x3, x4, x5)) = 0   
POL(new_primQuotInt99(x1, x2)) = 0   

The following usable rules [17] were oriented: none



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Instantiation
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ QDPOrderProof
                                                                                                                            ↳ QDP
                                                                                                                              ↳ QDPOrderProof
QDP
                                                                                                                                  ↳ DependencyGraphProof
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Neg(Zero), vvv1052) → new_primQuotInt110(vvv1041, vvv10430)
new_primQuotInt115(z0, z1, z2, Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Neg(Zero)) → new_primQuotInt113(vvv1194, vvv1196, vvv1195)
new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt109(vvv1272, Succ(vvv12730), Zero, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt109(vvv1272, Succ(vvv12730), Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt109(vvv1272, vvv12730, vvv12740, vvv1275, vvv1276)
new_primQuotInt100(z0, z1, z2, Pos(Zero)) → new_primQuotInt105(z0, z1, z2, Pos(Zero))
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt100(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Succ(vvv121000))) → new_primQuotInt98(vvv1205, Succ(vvv1206), vvv121000, vvv1207, Succ(vvv1206))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt98(vvv1279, Zero, Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt104(vvv1279, vvv1282, vvv1283)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt100(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt105(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt116(vvv1272, vvv1275, vvv1276) → new_primQuotInt108(vvv1272, vvv1275, vvv1276, Pos(Zero))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt98(vvv1006, Zero, vvv101100, Succ(vvv10080), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt98(vvv1279, Succ(vvv12800), Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt98(vvv1279, vvv12800, vvv12810, vvv1282, vvv1283)
new_primQuotInt105(z0, z1, z2, Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt108(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt115(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt108(z0, z2, z3, Pos(Zero)) → new_primQuotInt115(z0, z2, z3, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Pos(vvv10460), vvv1052) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt109(vvv1272, Zero, Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt116(vvv1272, vvv1275, vvv1276)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 2 SCCs with 5 less nodes.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Instantiation
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ QDPOrderProof
                                                                                                                            ↳ QDP
                                                                                                                              ↳ QDPOrderProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                    ↳ AND
QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                      ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt115(z0, z1, z2, Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt100(z0, z1, z2, Pos(Zero)) → new_primQuotInt105(z0, z1, z2, Pos(Zero))
new_primQuotInt100(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Succ(vvv121000))) → new_primQuotInt98(vvv1205, Succ(vvv1206), vvv121000, vvv1207, Succ(vvv1206))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt98(vvv1279, Zero, Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt104(vvv1279, vvv1282, vvv1283)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt100(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt105(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt98(vvv1006, Zero, vvv101100, Succ(vvv10080), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt98(vvv1279, Succ(vvv12800), Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt98(vvv1279, vvv12800, vvv12810, vvv1282, vvv1283)
new_primQuotInt105(z0, z1, z2, Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt108(z0, z2, z3, Pos(Zero)) → new_primQuotInt115(z0, z2, z3, Pos(Zero))
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt108(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt115(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Pos(vvv10460), vvv1052) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt108(z0, z2, z3, Pos(Zero)) → new_primQuotInt115(z0, z2, z3, Pos(Zero)) we obtained the following new rules:

new_primQuotInt108(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt115(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Instantiation
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ QDPOrderProof
                                                                                                                            ↳ QDP
                                                                                                                              ↳ QDPOrderProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                    ↳ AND
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                      ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt115(z0, z1, z2, Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt100(z0, z1, z2, Pos(Zero)) → new_primQuotInt105(z0, z1, z2, Pos(Zero))
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt100(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Succ(vvv121000))) → new_primQuotInt98(vvv1205, Succ(vvv1206), vvv121000, vvv1207, Succ(vvv1206))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt98(vvv1279, Zero, Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt104(vvv1279, vvv1282, vvv1283)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt100(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt105(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt98(vvv1006, Zero, vvv101100, Succ(vvv10080), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt98(vvv1279, Succ(vvv12800), Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt98(vvv1279, vvv12800, vvv12810, vvv1282, vvv1283)
new_primQuotInt105(z0, z1, z2, Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt108(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt115(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Pos(vvv10460), vvv1052) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt115(z0, z1, z2, Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), z2, Pos(Zero), Succ(z1)) we obtained the following new rules:

new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt115(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt94(z0, Succ(Succ(z1)), Zero, Pos(Zero), Succ(Succ(z1)))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Instantiation
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ QDPOrderProof
                                                                                                                            ↳ QDP
                                                                                                                              ↳ QDPOrderProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                    ↳ AND
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
QDP
                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt100(z0, z1, z2, Pos(Zero)) → new_primQuotInt105(z0, z1, z2, Pos(Zero))
new_primQuotInt100(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Succ(vvv121000))) → new_primQuotInt98(vvv1205, Succ(vvv1206), vvv121000, vvv1207, Succ(vvv1206))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt98(vvv1279, Zero, Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt104(vvv1279, vvv1282, vvv1283)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt100(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt105(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt98(vvv1006, Zero, vvv101100, Succ(vvv10080), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt98(vvv1279, Succ(vvv12800), Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt98(vvv1279, vvv12800, vvv12810, vvv1282, vvv1283)
new_primQuotInt105(z0, z1, z2, Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt108(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt115(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt106(vvv1041, Succ(Zero), Succ(vvv10430), Pos(vvv10460), vvv1052) → new_primQuotInt108(vvv1041, Succ(vvv10430), Zero, Pos(Zero))
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt115(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt94(z0, Succ(Succ(z1)), Zero, Pos(Zero), Succ(Succ(z1)))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 3 less nodes.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Instantiation
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ QDPOrderProof
                                                                                                                            ↳ QDP
                                                                                                                              ↳ QDPOrderProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                    ↳ AND
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ DependencyGraphProof
QDP
                                                                                                                                                    ↳ QDPOrderProof
                                                                                                                                      ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt100(z0, z1, z2, Pos(Zero)) → new_primQuotInt105(z0, z1, z2, Pos(Zero))
new_primQuotInt100(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Succ(vvv121000))) → new_primQuotInt98(vvv1205, Succ(vvv1206), vvv121000, vvv1207, Succ(vvv1206))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt98(vvv1279, Zero, Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt104(vvv1279, vvv1282, vvv1283)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt100(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt105(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt98(vvv1006, Zero, vvv101100, Succ(vvv10080), Zero)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt98(vvv1279, Succ(vvv12800), Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt98(vvv1279, vvv12800, vvv12810, vvv1282, vvv1283)
new_primQuotInt105(z0, z1, z2, Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Succ(vvv121000))) → new_primQuotInt98(vvv1205, Succ(vvv1206), vvv121000, vvv1207, Succ(vvv1206))
new_primQuotInt98(vvv1279, Zero, Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt104(vvv1279, vvv1282, vvv1283)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Succ(vvv101100)), vvv1034) → new_primQuotInt98(vvv1006, Zero, vvv101100, Succ(vvv10080), Zero)
new_primQuotInt98(vvv1279, Succ(vvv12800), Succ(vvv12810), vvv1282, vvv1283) → new_primQuotInt98(vvv1279, vvv12800, vvv12810, vvv1282, vvv1283)
The remaining pairs can at least be oriented weakly.

new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt100(z0, z1, z2, Pos(Zero)) → new_primQuotInt105(z0, z1, z2, Pos(Zero))
new_primQuotInt100(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt100(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt105(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt105(z0, z1, z2, Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
Used ordering: Polynomial interpretation [25]:

POL(Pos(x1)) = 1 + x1   
POL(Succ(x1)) = 1 + x1   
POL(Zero) = 0   
POL(new_primMinusNatS2(x1, x2)) = 0   
POL(new_primQuotInt100(x1, x2, x3, x4)) = x4   
POL(new_primQuotInt102(x1, x2, x3)) = 1   
POL(new_primQuotInt103(x1, x2, x3, x4)) = x4   
POL(new_primQuotInt104(x1, x2, x3)) = 1   
POL(new_primQuotInt105(x1, x2, x3, x4)) = x4   
POL(new_primQuotInt106(x1, x2, x3, x4, x5)) = x4   
POL(new_primQuotInt107(x1, x2, x3, x4, x5, x6)) = x6   
POL(new_primQuotInt108(x1, x2, x3, x4)) = 1   
POL(new_primQuotInt114(x1, x2, x3, x4)) = x4   
POL(new_primQuotInt115(x1, x2, x3, x4)) = 1   
POL(new_primQuotInt94(x1, x2, x3, x4, x5)) = x4   
POL(new_primQuotInt97(x1, x2, x3, x4, x5, x6)) = x6   
POL(new_primQuotInt98(x1, x2, x3, x4, x5)) = 1 + x3   
POL(new_primQuotInt99(x1, x2)) = 1   

The following usable rules [17] were oriented: none



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Instantiation
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ QDPOrderProof
                                                                                                                            ↳ QDP
                                                                                                                              ↳ QDPOrderProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                    ↳ AND
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ QDPOrderProof
QDP
                                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt100(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt105(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt100(z0, z1, z2, Pos(Zero)) → new_primQuotInt105(z0, z1, z2, Pos(Zero))
new_primQuotInt100(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt105(z0, z1, z2, Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt104(vvv1279, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt98(vvv1279, Succ(vvv12800), Zero, vvv1282, vvv1283) → new_primQuotInt100(vvv1279, vvv1282, vvv1283, Pos(Zero))
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 2 less nodes.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Instantiation
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ QDPOrderProof
                                                                                                                            ↳ QDP
                                                                                                                              ↳ QDPOrderProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                    ↳ AND
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ QDPOrderProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ DependencyGraphProof
QDP
                                                                                                                                                            ↳ Instantiation
                                                                                                                                      ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt100(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt105(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt100(z0, z1, z2, Pos(Zero)) → new_primQuotInt105(z0, z1, z2, Pos(Zero))
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt100(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt105(z0, z1, z2, Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt100(z0, z1, z2, Pos(Zero)) → new_primQuotInt105(z0, z1, z2, Pos(Zero)) we obtained the following new rules:

new_primQuotInt100(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt105(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt100(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Instantiation
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ QDPOrderProof
                                                                                                                            ↳ QDP
                                                                                                                              ↳ QDPOrderProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                    ↳ AND
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ QDPOrderProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ Instantiation
QDP
                                                                                                                                                                ↳ Instantiation
                                                                                                                                      ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt100(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt105(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt100(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt105(z0, z1, z2, Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt105(z0, z1, z2, Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), z2, Pos(Zero), Succ(z1)) we obtained the following new rules:

new_primQuotInt105(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt106(z0, Succ(Succ(z1)), Zero, Pos(Zero), Succ(Succ(z1)))
new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Instantiation
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ QDPOrderProof
                                                                                                                            ↳ QDP
                                                                                                                              ↳ QDPOrderProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                    ↳ AND
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ QDPOrderProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ Instantiation
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Instantiation
QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt100(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt105(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt105(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt106(z0, Succ(Succ(z1)), Zero, Pos(Zero), Succ(Succ(z1)))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt100(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt94(vvv1006, Succ(Zero), Succ(vvv10080), Pos(Zero), vvv1034) → new_primQuotInt99(vvv1006, vvv10080)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt99(vvv1006, vvv10080) → new_primQuotInt100(vvv1006, Succ(vvv10080), Zero, Pos(Zero))
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 4 less nodes.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Instantiation
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ QDPOrderProof
                                                                                                                            ↳ QDP
                                                                                                                              ↳ QDPOrderProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                    ↳ AND
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ QDPOrderProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ Instantiation
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
QDP
                                                                                                                                                                        ↳ QDPOrderProof
                                                                                                                                      ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt100(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Zero, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Zero, vvv1199) → new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199)
The remaining pairs can at least be oriented weakly.

new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt100(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
Used ordering: Matrix interpretation [3]:
Non-tuple symbols:
M( Succ(x1) ) =
/1\
\0/
+
/00\
\11/
·x1

M( new_primMinusNatS2(x1, x2) ) =
/1\
\0/
+
/00\
\01/
·x1+
/00\
\00/
·x2

M( Zero ) =
/0\
\0/

M( Pos(x1) ) =
/1\
\1/
+
/00\
\00/
·x1

Tuple symbols:
M( new_primQuotInt107(x1, ..., x6) ) = 1+
[0,0]
·x1+
[1,1]
·x2+
[0,0]
·x3+
[0,0]
·x4+
[0,0]
·x5+
[0,0]
·x6

M( new_primQuotInt106(x1, ..., x5) ) = 0+
[0,0]
·x1+
[0,1]
·x2+
[0,0]
·x3+
[0,0]
·x4+
[0,0]
·x5

M( new_primQuotInt94(x1, ..., x5) ) = 0+
[0,0]
·x1+
[0,0]
·x2+
[1,1]
·x3+
[0,0]
·x4+
[0,0]
·x5

M( new_primQuotInt115(x1, ..., x4) ) = 0+
[0,0]
·x1+
[0,0]
·x2+
[0,1]
·x3+
[1,0]
·x4

M( new_primQuotInt114(x1, ..., x4) ) = 0+
[0,0]
·x1+
[1,1]
·x2+
[0,0]
·x3+
[0,0]
·x4

M( new_primQuotInt102(x1, ..., x3) ) = 0+
[0,0]
·x1+
[1,1]
·x2+
[0,0]
·x3

M( new_primQuotInt105(x1, ..., x4) ) = 0+
[0,0]
·x1+
[1,1]
·x2+
[0,0]
·x3+
[0,0]
·x4

M( new_primQuotInt108(x1, ..., x4) ) = 0+
[0,0]
·x1+
[0,0]
·x2+
[0,1]
·x3+
[0,1]
·x4

M( new_primQuotInt103(x1, ..., x4) ) = 0+
[0,0]
·x1+
[0,0]
·x2+
[1,1]
·x3+
[0,0]
·x4

M( new_primQuotInt97(x1, ..., x6) ) = 0+
[0,0]
·x1+
[0,0]
·x2+
[1,1]
·x3+
[0,0]
·x4+
[0,0]
·x5+
[0,0]
·x6

M( new_primQuotInt100(x1, ..., x4) ) = 0+
[0,0]
·x1+
[1,1]
·x2+
[0,0]
·x3+
[0,0]
·x4


Matrix type:
We used a basic matrix type which is not further parametrizeable.


As matrix orders are CE-compatible, we used usable rules w.r.t. argument filtering in the order.
The following usable rules [17] were oriented:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Instantiation
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ QDPOrderProof
                                                                                                                            ↳ QDP
                                                                                                                              ↳ QDPOrderProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                    ↳ AND
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ QDPOrderProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ Instantiation
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ QDPOrderProof
QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt100(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt114(vvv1194, vvv1195, vvv1196, vvv1199) → new_primQuotInt106(vvv1194, new_primMinusNatS2(Succ(vvv1195), vvv1196), vvv1196, vvv1199, new_primMinusNatS2(Succ(vvv1195), vvv1196))
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Instantiation
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ QDPOrderProof
                                                                                                                            ↳ QDP
                                                                                                                              ↳ QDPOrderProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                    ↳ AND
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ QDPOrderProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ Instantiation
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ QDPOrderProof
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
QDP
                                                                                                                                                                                ↳ Instantiation
                                                                                                                                      ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt100(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt106(vvv1041, Succ(Succ(vvv105300)), Succ(vvv10430), vvv1046, vvv1052) → new_primQuotInt107(vvv1041, vvv105300, Succ(vvv10430), vvv105300, vvv10430, vvv1046) we obtained the following new rules:

new_primQuotInt106(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt107(z0, x1, Succ(z2), x1, z2, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Instantiation
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ QDPOrderProof
                                                                                                                            ↳ QDP
                                                                                                                              ↳ QDPOrderProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                    ↳ AND
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ QDPOrderProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ Instantiation
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ QDPOrderProof
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Instantiation
QDP
                                                                                                                                                                                    ↳ QDPOrderProof
                                                                                                                                      ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt100(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
new_primQuotInt106(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt107(z0, x1, Succ(z2), x1, z2, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Zero, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Zero, vvv1210) → new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210)
The remaining pairs can at least be oriented weakly.

new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt100(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt106(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt107(z0, x1, Succ(z2), x1, z2, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
Used ordering: Matrix interpretation [3]:
Non-tuple symbols:
M( Succ(x1) ) =
/1\
\0/
+
/00\
\11/
·x1

M( new_primMinusNatS2(x1, x2) ) =
/1\
\0/
+
/00\
\01/
·x1+
/00\
\00/
·x2

M( Zero ) =
/0\
\0/

M( Pos(x1) ) =
/0\
\1/
+
/00\
\00/
·x1

Tuple symbols:
M( new_primQuotInt107(x1, ..., x6) ) = 0+
[0,0]
·x1+
[0,0]
·x2+
[1,1]
·x3+
[0,0]
·x4+
[0,0]
·x5+
[0,0]
·x6

M( new_primQuotInt106(x1, ..., x5) ) = 0+
[0,0]
·x1+
[0,0]
·x2+
[0,1]
·x3+
[0,1]
·x4+
[0,0]
·x5

M( new_primQuotInt94(x1, ..., x5) ) = 0+
[0,0]
·x1+
[0,1]
·x2+
[0,0]
·x3+
[0,0]
·x4+
[0,0]
·x5

M( new_primQuotInt115(x1, ..., x4) ) = 0+
[0,0]
·x1+
[1,1]
·x2+
[0,0]
·x3+
[0,0]
·x4

M( new_primQuotInt102(x1, ..., x3) ) = 1+
[0,0]
·x1+
[0,0]
·x2+
[1,1]
·x3

M( new_primQuotInt105(x1, ..., x4) ) = 0+
[0,0]
·x1+
[0,0]
·x2+
[0,1]
·x3+
[0,1]
·x4

M( new_primQuotInt108(x1, ..., x4) ) = 0+
[0,0]
·x1+
[1,1]
·x2+
[0,0]
·x3+
[0,0]
·x4

M( new_primQuotInt103(x1, ..., x4) ) = 0+
[0,0]
·x1+
[1,1]
·x2+
[0,0]
·x3+
[0,0]
·x4

M( new_primQuotInt97(x1, ..., x6) ) = 1+
[0,0]
·x1+
[1,1]
·x2+
[0,0]
·x3+
[0,0]
·x4+
[0,0]
·x5+
[0,0]
·x6

M( new_primQuotInt100(x1, ..., x4) ) = 0+
[0,0]
·x1+
[0,0]
·x2+
[0,1]
·x3+
[0,1]
·x4


Matrix type:
We used a basic matrix type which is not further parametrizeable.


As matrix orders are CE-compatible, we used usable rules w.r.t. argument filtering in the order.
The following usable rules [17] were oriented:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Instantiation
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ QDPOrderProof
                                                                                                                            ↳ QDP
                                                                                                                              ↳ QDPOrderProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                    ↳ AND
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ QDPOrderProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ Instantiation
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ QDPOrderProof
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ QDPOrderProof
QDP
                                                                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt106(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt107(z0, x1, Succ(z2), x1, z2, Pos(Zero))
new_primQuotInt103(vvv1205, vvv1206, vvv1207, vvv1210) → new_primQuotInt94(vvv1205, new_primMinusNatS2(Succ(vvv1206), vvv1207), vvv1207, vvv1210, new_primMinusNatS2(Succ(vvv1206), vvv1207))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt100(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Instantiation
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ QDPOrderProof
                                                                                                                            ↳ QDP
                                                                                                                              ↳ QDPOrderProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                    ↳ AND
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ QDPOrderProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ Instantiation
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ QDPOrderProof
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ QDPOrderProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ DependencyGraphProof
QDP
                                                                                                                                                                                            ↳ UsableRulesProof
                                                                                                                                      ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt106(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt107(z0, x1, Succ(z2), x1, z2, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt100(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Instantiation
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ QDPOrderProof
                                                                                                                            ↳ QDP
                                                                                                                              ↳ QDPOrderProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                    ↳ AND
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ QDPOrderProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ Instantiation
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ QDPOrderProof
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ QDPOrderProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ UsableRulesProof
QDP
                                                                                                                                                                                                ↳ QReductionProof
                                                                                                                                      ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt106(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt107(z0, x1, Succ(z2), x1, z2, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt100(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero))

R is empty.
The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Instantiation
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ QDPOrderProof
                                                                                                                            ↳ QDP
                                                                                                                              ↳ QDPOrderProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                    ↳ AND
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ QDPOrderProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ Instantiation
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ QDPOrderProof
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ QDPOrderProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ UsableRulesProof
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ QReductionProof
QDP
                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt106(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt107(z0, x1, Succ(z2), x1, z2, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt100(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt94(vvv1006, Succ(Succ(vvv103500)), Succ(vvv10080), vvv1011, vvv1034) → new_primQuotInt97(vvv1006, vvv103500, Succ(vvv10080), vvv103500, vvv10080, vvv1011) we obtained the following new rules:

new_primQuotInt94(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt97(z0, x1, Succ(z2), x1, z2, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Instantiation
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ QDPOrderProof
                                                                                                                            ↳ QDP
                                                                                                                              ↳ QDPOrderProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                    ↳ AND
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ QDPOrderProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ Instantiation
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ QDPOrderProof
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ QDPOrderProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ UsableRulesProof
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ QReductionProof
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ Instantiation
QDP
                                                                                                                                                                                                        ↳ NonInfProof
                                                                                                                                      ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt106(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt107(z0, x1, Succ(z2), x1, z2, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt94(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt97(z0, x1, Succ(z2), x1, z2, Pos(Zero))
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt100(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The DP Problem is simplified using the Induction Calculus [18] with the following steps:
Note that final constraints are written in bold face.


For Pair new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero)) the following chains were created:




For Pair new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1)) the following chains were created:




For Pair new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1)) the following chains were created:




For Pair new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199) the following chains were created:




For Pair new_primQuotInt106(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt107(z0, x1, Succ(z2), x1, z2, Pos(Zero)) the following chains were created:




For Pair new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206) the following chains were created:




For Pair new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210) the following chains were created:




For Pair new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero)) the following chains were created:




For Pair new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero)) the following chains were created:




For Pair new_primQuotInt100(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero)) the following chains were created:




For Pair new_primQuotInt94(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt97(z0, x1, Succ(z2), x1, z2, Pos(Zero)) the following chains were created:




To summarize, we get the following constraints P for the following pairs.



The constraints for P> respective Pbound are constructed from P where we just replace every occurence of "t ≥ s" in P by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for Pbound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation [18]:

POL(Pos(x1)) = 0   
POL(Succ(x1)) = 1 + x1   
POL(Zero) = 0   
POL(c) = -1   
POL(new_primQuotInt100(x1, x2, x3, x4)) = -1 + x1 + x3 + x4   
POL(new_primQuotInt102(x1, x2, x3)) = x1 + x3   
POL(new_primQuotInt105(x1, x2, x3, x4)) = -1 + x1 + x3 - x4   
POL(new_primQuotInt106(x1, x2, x3, x4, x5)) = -1 + x1 + x2 + x3 + x4 - x5   
POL(new_primQuotInt107(x1, x2, x3, x4, x5, x6)) = -1 + x1 + x2 - x4 + x5 - x6   
POL(new_primQuotInt108(x1, x2, x3, x4)) = -1 + x1 + x3 - x4   
POL(new_primQuotInt115(x1, x2, x3, x4)) = -1 + x1 + x3 - x4   
POL(new_primQuotInt94(x1, x2, x3, x4, x5)) = -1 + x1 - x2 + x3 + x4 + x5   
POL(new_primQuotInt97(x1, x2, x3, x4, x5, x6)) = -1 + x1 + x2 - x4 + x5 - x6   

The following pairs are in P>:

new_primQuotInt106(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt107(z0, x1, Succ(z2), x1, z2, Pos(Zero))
new_primQuotInt94(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt97(z0, x1, Succ(z2), x1, z2, Pos(Zero))
The following pairs are in Pbound:

new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt106(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt107(z0, x1, Succ(z2), x1, z2, Pos(Zero))
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt100(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt94(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt97(z0, x1, Succ(z2), x1, z2, Pos(Zero))
There are no usable rules

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Instantiation
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ QDPOrderProof
                                                                                                                            ↳ QDP
                                                                                                                              ↳ QDPOrderProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                    ↳ AND
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ QDPOrderProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ Instantiation
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ QDPOrderProof
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ QDPOrderProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ UsableRulesProof
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ QReductionProof
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ NonInfProof
QDP
                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt107(vvv1194, vvv1195, vvv1196, Zero, Succ(vvv11980), Pos(vvv11990)) → new_primQuotInt108(vvv1194, vvv1196, Succ(vvv1195), Pos(Zero))
new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt106(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt115(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt94(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Zero, Succ(vvv12090), Pos(Zero)) → new_primQuotInt102(vvv1205, vvv1207, vvv1206)
new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)
new_primQuotInt108(z0, z2, Succ(z1), Pos(Zero)) → new_primQuotInt115(z0, z2, Succ(z1), Pos(Zero))
new_primQuotInt102(vvv1205, vvv1207, vvv1206) → new_primQuotInt100(vvv1205, vvv1207, Succ(vvv1206), Pos(Zero))
new_primQuotInt100(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt105(z0, z1, Succ(z2), Pos(Zero))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 2 SCCs with 7 less nodes.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Instantiation
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ QDPOrderProof
                                                                                                                            ↳ QDP
                                                                                                                              ↳ QDPOrderProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                    ↳ AND
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ QDPOrderProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ Instantiation
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ QDPOrderProof
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ QDPOrderProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ UsableRulesProof
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ QReductionProof
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ NonInfProof
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                              ↳ AND
QDP
                                                                                                                                                                                                                  ↳ QDPSizeChangeProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                      ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt97(vvv1205, vvv1206, vvv1207, Succ(vvv12080), Succ(vvv12090), vvv1210) → new_primQuotInt97(vvv1205, vvv1206, vvv1207, vvv12080, vvv12090, vvv1210)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Instantiation
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ QDPOrderProof
                                                                                                                            ↳ QDP
                                                                                                                              ↳ QDPOrderProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                    ↳ AND
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ QDPOrderProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ Instantiation
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ QDPOrderProof
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ QDPOrderProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ DependencyGraphProof
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ UsableRulesProof
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ QReductionProof
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ NonInfProof
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                              ↳ AND
                                                                                                                                                                                                                ↳ QDP
QDP
                                                                                                                                                                                                                  ↳ QDPSizeChangeProof
                                                                                                                                      ↳ QDP
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt107(vvv1194, vvv1195, vvv1196, Succ(vvv11970), Succ(vvv11980), vvv1199) → new_primQuotInt107(vvv1194, vvv1195, vvv1196, vvv11970, vvv11980, vvv1199)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Instantiation
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ QDPOrderProof
                                                                                                                            ↳ QDP
                                                                                                                              ↳ QDPOrderProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                    ↳ AND
                                                                                                                                      ↳ QDP
QDP
                                                                                                                                        ↳ UsableRulesProof
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt109(vvv1272, Succ(vvv12730), Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt109(vvv1272, vvv12730, vvv12740, vvv1275, vvv1276)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Instantiation
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ QDPOrderProof
                                                                                                                            ↳ QDP
                                                                                                                              ↳ QDPOrderProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                    ↳ AND
                                                                                                                                      ↳ QDP
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ UsableRulesProof
QDP
                                                                                                                                            ↳ QReductionProof
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt109(vvv1272, Succ(vvv12730), Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt109(vvv1272, vvv12730, vvv12740, vvv1275, vvv1276)

R is empty.
The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Rewriting
                                                                    ↳ QDP
                                                                      ↳ Rewriting
                                                                        ↳ QDP
                                                                          ↳ Rewriting
                                                                            ↳ QDP
                                                                              ↳ Rewriting
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Rewriting
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Instantiation
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ QDPOrderProof
                                                                                                                            ↳ QDP
                                                                                                                              ↳ QDPOrderProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                    ↳ AND
                                                                                                                                      ↳ QDP
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ QReductionProof
QDP
                                                                                                                                                ↳ QDPSizeChangeProof
                                ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt109(vvv1272, Succ(vvv12730), Succ(vvv12740), vvv1275, vvv1276) → new_primQuotInt109(vvv1272, vvv12730, vvv12740, vvv1275, vvv1276)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
QDP
                                  ↳ UsableRulesProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Succ(vvv87500)), vvv888) → new_primQuotInt80(vvv870, Zero, vvv87500, Succ(vvv8720), Zero)
new_primQuotInt80(vvv1236, Zero, Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt87(vvv1236, vvv1239, vvv1240)
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Succ(vvv9860), vvv987) → new_primQuotInt79(vvv982, vvv983, vvv984, vvv9850, vvv9860, vvv987)
new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), new_fromInt)
new_primQuotInt86(vvv982, vvv983, vvv984, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Zero)) → new_primQuotInt85(vvv982, vvv984, vvv983)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Zero, vvv987) → new_primQuotInt86(vvv982, vvv983, vvv984, vvv987)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Succ(vvv98700))) → new_primQuotInt80(vvv982, Succ(vvv983), vvv98700, vvv984, Succ(vvv983))
new_primQuotInt82(vvv1236, vvv1239, vvv1240, vvv1246) → new_primQuotInt88(vvv1236, vvv1239, vvv1240, vvv1246)
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Zero), vvv888) → new_primQuotInt81(vvv870, vvv8720)
new_primQuotInt81(vvv870, vvv8720) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, new_fromInt)
new_primQuotInt87(vvv1236, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, new_fromInt)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Neg(vvv9870)) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), new_fromInt)
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Neg(vvv8750), vvv888) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, new_fromInt)
new_primQuotInt80(vvv1236, Succ(vvv12370), Zero, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, new_fromInt)
new_primQuotInt80(vvv1236, Succ(vvv12370), Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt80(vvv1236, vvv12370, vvv12380, vvv1239, vvv1240)
new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Succ(vvv8720), vvv875, vvv888) → new_primQuotInt79(vvv870, vvv88900, Succ(vvv8720), vvv88900, vvv8720, vvv875)
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Zero, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt88(vvv115, vvv2200, vvv1160, vvv272) → new_primQuotInt78(vvv115, Succ(vvv2200), vvv1160, vvv272, Succ(vvv2200))

The TRS R consists of the following rules:

new_primRemInt3(vvv46800) → new_error
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_rem1(vvv1030) → new_primRemInt4(vvv1030)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_errorerror([])
new_rem(vvv1160) → new_primRemInt5(vvv1160)
new_rem0(vvv1008) → new_primRemInt3(vvv1008)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Zero) → Zero
new_rem2(vvv47200) → new_primRemInt6(vvv47200)
new_primRemInt6(vvv47200) → new_error
new_fromIntPos(Zero)
new_primRemInt5(vvv2200) → new_error
new_primRemInt4(vvv2200) → new_error

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
QDP
                                      ↳ QReductionProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Succ(vvv87500)), vvv888) → new_primQuotInt80(vvv870, Zero, vvv87500, Succ(vvv8720), Zero)
new_primQuotInt80(vvv1236, Zero, Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt87(vvv1236, vvv1239, vvv1240)
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Succ(vvv9860), vvv987) → new_primQuotInt79(vvv982, vvv983, vvv984, vvv9850, vvv9860, vvv987)
new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), new_fromInt)
new_primQuotInt86(vvv982, vvv983, vvv984, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Zero)) → new_primQuotInt85(vvv982, vvv984, vvv983)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Zero, vvv987) → new_primQuotInt86(vvv982, vvv983, vvv984, vvv987)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Succ(vvv98700))) → new_primQuotInt80(vvv982, Succ(vvv983), vvv98700, vvv984, Succ(vvv983))
new_primQuotInt82(vvv1236, vvv1239, vvv1240, vvv1246) → new_primQuotInt88(vvv1236, vvv1239, vvv1240, vvv1246)
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Zero), vvv888) → new_primQuotInt81(vvv870, vvv8720)
new_primQuotInt81(vvv870, vvv8720) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, new_fromInt)
new_primQuotInt87(vvv1236, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, new_fromInt)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Neg(vvv9870)) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), new_fromInt)
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Neg(vvv8750), vvv888) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, new_fromInt)
new_primQuotInt80(vvv1236, Succ(vvv12370), Zero, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, new_fromInt)
new_primQuotInt80(vvv1236, Succ(vvv12370), Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt80(vvv1236, vvv12370, vvv12380, vvv1239, vvv1240)
new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Succ(vvv8720), vvv875, vvv888) → new_primQuotInt79(vvv870, vvv88900, Succ(vvv8720), vvv88900, vvv8720, vvv875)
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Zero, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt88(vvv115, vvv2200, vvv1160, vvv272) → new_primQuotInt78(vvv115, Succ(vvv2200), vvv1160, vvv272, Succ(vvv2200))

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_primMinusNatS2(Zero, Succ(x0))
new_error
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_rem0(x0)
new_rem2(x0)
new_rem1(x0)
new_rem(x0)
new_primRemInt6(x0)
new_error
new_primRemInt3(x0)
new_primRemInt4(x0)
new_primRemInt5(x0)



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
QDP
                                          ↳ Rewriting
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Succ(vvv87500)), vvv888) → new_primQuotInt80(vvv870, Zero, vvv87500, Succ(vvv8720), Zero)
new_primQuotInt80(vvv1236, Zero, Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt87(vvv1236, vvv1239, vvv1240)
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Succ(vvv9860), vvv987) → new_primQuotInt79(vvv982, vvv983, vvv984, vvv9850, vvv9860, vvv987)
new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), new_fromInt)
new_primQuotInt86(vvv982, vvv983, vvv984, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Zero)) → new_primQuotInt85(vvv982, vvv984, vvv983)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Zero, vvv987) → new_primQuotInt86(vvv982, vvv983, vvv984, vvv987)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Succ(vvv98700))) → new_primQuotInt80(vvv982, Succ(vvv983), vvv98700, vvv984, Succ(vvv983))
new_primQuotInt82(vvv1236, vvv1239, vvv1240, vvv1246) → new_primQuotInt88(vvv1236, vvv1239, vvv1240, vvv1246)
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Zero), vvv888) → new_primQuotInt81(vvv870, vvv8720)
new_primQuotInt81(vvv870, vvv8720) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, new_fromInt)
new_primQuotInt87(vvv1236, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, new_fromInt)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Neg(vvv9870)) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), new_fromInt)
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Neg(vvv8750), vvv888) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, new_fromInt)
new_primQuotInt80(vvv1236, Succ(vvv12370), Zero, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, new_fromInt)
new_primQuotInt80(vvv1236, Succ(vvv12370), Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt80(vvv1236, vvv12370, vvv12380, vvv1239, vvv1240)
new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Succ(vvv8720), vvv875, vvv888) → new_primQuotInt79(vvv870, vvv88900, Succ(vvv8720), vvv88900, vvv8720, vvv875)
new_primQuotInt88(vvv115, vvv2200, vvv1160, vvv272) → new_primQuotInt78(vvv115, Succ(vvv2200), vvv1160, vvv272, Succ(vvv2200))
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Zero, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
QDP
                                              ↳ Rewriting
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Succ(vvv87500)), vvv888) → new_primQuotInt80(vvv870, Zero, vvv87500, Succ(vvv8720), Zero)
new_primQuotInt80(vvv1236, Zero, Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt87(vvv1236, vvv1239, vvv1240)
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Succ(vvv9860), vvv987) → new_primQuotInt79(vvv982, vvv983, vvv984, vvv9850, vvv9860, vvv987)
new_primQuotInt86(vvv982, vvv983, vvv984, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Zero)) → new_primQuotInt85(vvv982, vvv984, vvv983)
new_primQuotInt82(vvv1236, vvv1239, vvv1240, vvv1246) → new_primQuotInt88(vvv1236, vvv1239, vvv1240, vvv1246)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Succ(vvv98700))) → new_primQuotInt80(vvv982, Succ(vvv983), vvv98700, vvv984, Succ(vvv983))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Zero, vvv987) → new_primQuotInt86(vvv982, vvv983, vvv984, vvv987)
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Zero), vvv888) → new_primQuotInt81(vvv870, vvv8720)
new_primQuotInt81(vvv870, vvv8720) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, new_fromInt)
new_primQuotInt87(vvv1236, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, new_fromInt)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Neg(vvv9870)) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), new_fromInt)
new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Neg(vvv8750), vvv888) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, new_fromInt)
new_primQuotInt80(vvv1236, Succ(vvv12370), Zero, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, new_fromInt)
new_primQuotInt80(vvv1236, Succ(vvv12370), Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt80(vvv1236, vvv12370, vvv12380, vvv1239, vvv1240)
new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Succ(vvv8720), vvv875, vvv888) → new_primQuotInt79(vvv870, vvv88900, Succ(vvv8720), vvv88900, vvv8720, vvv875)
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Zero, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt88(vvv115, vvv2200, vvv1160, vvv272) → new_primQuotInt78(vvv115, Succ(vvv2200), vvv1160, vvv272, Succ(vvv2200))

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt81(vvv870, vvv8720) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt81(vvv870, vvv8720) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
QDP
                                                  ↳ Rewriting
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Succ(vvv87500)), vvv888) → new_primQuotInt80(vvv870, Zero, vvv87500, Succ(vvv8720), Zero)
new_primQuotInt80(vvv1236, Zero, Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt87(vvv1236, vvv1239, vvv1240)
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Succ(vvv9860), vvv987) → new_primQuotInt79(vvv982, vvv983, vvv984, vvv9850, vvv9860, vvv987)
new_primQuotInt86(vvv982, vvv983, vvv984, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Zero)) → new_primQuotInt85(vvv982, vvv984, vvv983)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Zero, vvv987) → new_primQuotInt86(vvv982, vvv983, vvv984, vvv987)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Succ(vvv98700))) → new_primQuotInt80(vvv982, Succ(vvv983), vvv98700, vvv984, Succ(vvv983))
new_primQuotInt82(vvv1236, vvv1239, vvv1240, vvv1246) → new_primQuotInt88(vvv1236, vvv1239, vvv1240, vvv1246)
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Zero), vvv888) → new_primQuotInt81(vvv870, vvv8720)
new_primQuotInt87(vvv1236, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, new_fromInt)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Neg(vvv9870)) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), new_fromInt)
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Neg(vvv8750), vvv888) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, new_fromInt)
new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt81(vvv870, vvv8720) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, Pos(Zero))
new_primQuotInt80(vvv1236, Succ(vvv12370), Zero, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, new_fromInt)
new_primQuotInt80(vvv1236, Succ(vvv12370), Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt80(vvv1236, vvv12370, vvv12380, vvv1239, vvv1240)
new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Succ(vvv8720), vvv875, vvv888) → new_primQuotInt79(vvv870, vvv88900, Succ(vvv8720), vvv88900, vvv8720, vvv875)
new_primQuotInt88(vvv115, vvv2200, vvv1160, vvv272) → new_primQuotInt78(vvv115, Succ(vvv2200), vvv1160, vvv272, Succ(vvv2200))
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Zero, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt87(vvv1236, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt87(vvv1236, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
QDP
                                                      ↳ Rewriting
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Succ(vvv87500)), vvv888) → new_primQuotInt80(vvv870, Zero, vvv87500, Succ(vvv8720), Zero)
new_primQuotInt80(vvv1236, Zero, Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt87(vvv1236, vvv1239, vvv1240)
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Succ(vvv9860), vvv987) → new_primQuotInt79(vvv982, vvv983, vvv984, vvv9850, vvv9860, vvv987)
new_primQuotInt86(vvv982, vvv983, vvv984, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Zero)) → new_primQuotInt85(vvv982, vvv984, vvv983)
new_primQuotInt82(vvv1236, vvv1239, vvv1240, vvv1246) → new_primQuotInt88(vvv1236, vvv1239, vvv1240, vvv1246)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Succ(vvv98700))) → new_primQuotInt80(vvv982, Succ(vvv983), vvv98700, vvv984, Succ(vvv983))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Zero, vvv987) → new_primQuotInt86(vvv982, vvv983, vvv984, vvv987)
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Zero), vvv888) → new_primQuotInt81(vvv870, vvv8720)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Neg(vvv9870)) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), new_fromInt)
new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Neg(vvv8750), vvv888) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, new_fromInt)
new_primQuotInt80(vvv1236, Succ(vvv12370), Zero, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, new_fromInt)
new_primQuotInt81(vvv870, vvv8720) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, Pos(Zero))
new_primQuotInt80(vvv1236, Succ(vvv12370), Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt80(vvv1236, vvv12370, vvv12380, vvv1239, vvv1240)
new_primQuotInt87(vvv1236, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, Pos(Zero))
new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Succ(vvv8720), vvv875, vvv888) → new_primQuotInt79(vvv870, vvv88900, Succ(vvv8720), vvv88900, vvv8720, vvv875)
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Zero, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt88(vvv115, vvv2200, vvv1160, vvv272) → new_primQuotInt78(vvv115, Succ(vvv2200), vvv1160, vvv272, Succ(vvv2200))

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Neg(vvv9870)) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Neg(vvv9870)) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
QDP
                                                          ↳ Rewriting
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Succ(vvv87500)), vvv888) → new_primQuotInt80(vvv870, Zero, vvv87500, Succ(vvv8720), Zero)
new_primQuotInt80(vvv1236, Zero, Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt87(vvv1236, vvv1239, vvv1240)
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Succ(vvv9860), vvv987) → new_primQuotInt79(vvv982, vvv983, vvv984, vvv9850, vvv9860, vvv987)
new_primQuotInt86(vvv982, vvv983, vvv984, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Zero)) → new_primQuotInt85(vvv982, vvv984, vvv983)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Zero, vvv987) → new_primQuotInt86(vvv982, vvv983, vvv984, vvv987)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Succ(vvv98700))) → new_primQuotInt80(vvv982, Succ(vvv983), vvv98700, vvv984, Succ(vvv983))
new_primQuotInt82(vvv1236, vvv1239, vvv1240, vvv1246) → new_primQuotInt88(vvv1236, vvv1239, vvv1240, vvv1246)
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Zero), vvv888) → new_primQuotInt81(vvv870, vvv8720)
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Neg(vvv8750), vvv888) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, new_fromInt)
new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt81(vvv870, vvv8720) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, Pos(Zero))
new_primQuotInt80(vvv1236, Succ(vvv12370), Zero, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, new_fromInt)
new_primQuotInt80(vvv1236, Succ(vvv12370), Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt80(vvv1236, vvv12370, vvv12380, vvv1239, vvv1240)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Neg(vvv9870)) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Succ(vvv8720), vvv875, vvv888) → new_primQuotInt79(vvv870, vvv88900, Succ(vvv8720), vvv88900, vvv8720, vvv875)
new_primQuotInt87(vvv1236, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, Pos(Zero))
new_primQuotInt88(vvv115, vvv2200, vvv1160, vvv272) → new_primQuotInt78(vvv115, Succ(vvv2200), vvv1160, vvv272, Succ(vvv2200))
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Zero, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Neg(vvv8750), vvv888) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Neg(vvv8750), vvv888) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
QDP
                                                              ↳ Rewriting
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Succ(vvv87500)), vvv888) → new_primQuotInt80(vvv870, Zero, vvv87500, Succ(vvv8720), Zero)
new_primQuotInt80(vvv1236, Zero, Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt87(vvv1236, vvv1239, vvv1240)
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Succ(vvv9860), vvv987) → new_primQuotInt79(vvv982, vvv983, vvv984, vvv9850, vvv9860, vvv987)
new_primQuotInt86(vvv982, vvv983, vvv984, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Zero)) → new_primQuotInt85(vvv982, vvv984, vvv983)
new_primQuotInt82(vvv1236, vvv1239, vvv1240, vvv1246) → new_primQuotInt88(vvv1236, vvv1239, vvv1240, vvv1246)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Succ(vvv98700))) → new_primQuotInt80(vvv982, Succ(vvv983), vvv98700, vvv984, Succ(vvv983))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Zero, vvv987) → new_primQuotInt86(vvv982, vvv983, vvv984, vvv987)
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Zero), vvv888) → new_primQuotInt81(vvv870, vvv8720)
new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt80(vvv1236, Succ(vvv12370), Zero, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, new_fromInt)
new_primQuotInt81(vvv870, vvv8720) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, Pos(Zero))
new_primQuotInt80(vvv1236, Succ(vvv12370), Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt80(vvv1236, vvv12370, vvv12380, vvv1239, vvv1240)
new_primQuotInt87(vvv1236, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, Pos(Zero))
new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Succ(vvv8720), vvv875, vvv888) → new_primQuotInt79(vvv870, vvv88900, Succ(vvv8720), vvv88900, vvv8720, vvv875)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Neg(vvv9870)) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Neg(vvv8750), vvv888) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Zero, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt88(vvv115, vvv2200, vvv1160, vvv272) → new_primQuotInt78(vvv115, Succ(vvv2200), vvv1160, vvv272, Succ(vvv2200))

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primQuotInt80(vvv1236, Succ(vvv12370), Zero, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, new_fromInt) at position [3] we obtained the following new rules:

new_primQuotInt80(vvv1236, Succ(vvv12370), Zero, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
QDP
                                                                  ↳ UsableRulesProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Succ(vvv87500)), vvv888) → new_primQuotInt80(vvv870, Zero, vvv87500, Succ(vvv8720), Zero)
new_primQuotInt80(vvv1236, Zero, Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt87(vvv1236, vvv1239, vvv1240)
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Succ(vvv9860), vvv987) → new_primQuotInt79(vvv982, vvv983, vvv984, vvv9850, vvv9860, vvv987)
new_primQuotInt86(vvv982, vvv983, vvv984, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Zero)) → new_primQuotInt85(vvv982, vvv984, vvv983)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Zero, vvv987) → new_primQuotInt86(vvv982, vvv983, vvv984, vvv987)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Succ(vvv98700))) → new_primQuotInt80(vvv982, Succ(vvv983), vvv98700, vvv984, Succ(vvv983))
new_primQuotInt82(vvv1236, vvv1239, vvv1240, vvv1246) → new_primQuotInt88(vvv1236, vvv1239, vvv1240, vvv1246)
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Zero), vvv888) → new_primQuotInt81(vvv870, vvv8720)
new_primQuotInt80(vvv1236, Succ(vvv12370), Zero, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, Pos(Zero))
new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt81(vvv870, vvv8720) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, Pos(Zero))
new_primQuotInt80(vvv1236, Succ(vvv12370), Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt80(vvv1236, vvv12370, vvv12380, vvv1239, vvv1240)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Neg(vvv9870)) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Succ(vvv8720), vvv875, vvv888) → new_primQuotInt79(vvv870, vvv88900, Succ(vvv8720), vvv88900, vvv8720, vvv875)
new_primQuotInt87(vvv1236, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, Pos(Zero))
new_primQuotInt88(vvv115, vvv2200, vvv1160, vvv272) → new_primQuotInt78(vvv115, Succ(vvv2200), vvv1160, vvv272, Succ(vvv2200))
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Zero, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Neg(vvv8750), vvv888) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, Pos(Zero))

The TRS R consists of the following rules:

new_fromIntPos(Zero)
new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
QDP
                                                                      ↳ QReductionProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Succ(vvv87500)), vvv888) → new_primQuotInt80(vvv870, Zero, vvv87500, Succ(vvv8720), Zero)
new_primQuotInt80(vvv1236, Zero, Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt87(vvv1236, vvv1239, vvv1240)
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Succ(vvv9860), vvv987) → new_primQuotInt79(vvv982, vvv983, vvv984, vvv9850, vvv9860, vvv987)
new_primQuotInt86(vvv982, vvv983, vvv984, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Zero)) → new_primQuotInt85(vvv982, vvv984, vvv983)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Zero, vvv987) → new_primQuotInt86(vvv982, vvv983, vvv984, vvv987)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Succ(vvv98700))) → new_primQuotInt80(vvv982, Succ(vvv983), vvv98700, vvv984, Succ(vvv983))
new_primQuotInt82(vvv1236, vvv1239, vvv1240, vvv1246) → new_primQuotInt88(vvv1236, vvv1239, vvv1240, vvv1246)
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Zero), vvv888) → new_primQuotInt81(vvv870, vvv8720)
new_primQuotInt80(vvv1236, Succ(vvv12370), Zero, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, Pos(Zero))
new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt81(vvv870, vvv8720) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, Pos(Zero))
new_primQuotInt80(vvv1236, Succ(vvv12370), Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt80(vvv1236, vvv12370, vvv12380, vvv1239, vvv1240)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Neg(vvv9870)) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt87(vvv1236, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, Pos(Zero))
new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Succ(vvv8720), vvv875, vvv888) → new_primQuotInt79(vvv870, vvv88900, Succ(vvv8720), vvv88900, vvv8720, vvv875)
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Neg(vvv8750), vvv888) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Zero, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt88(vvv115, vvv2200, vvv1160, vvv272) → new_primQuotInt78(vvv115, Succ(vvv2200), vvv1160, vvv272, Succ(vvv2200))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_fromInt
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_fromInt



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
QDP
                                                                          ↳ Instantiation
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Succ(vvv87500)), vvv888) → new_primQuotInt80(vvv870, Zero, vvv87500, Succ(vvv8720), Zero)
new_primQuotInt80(vvv1236, Zero, Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt87(vvv1236, vvv1239, vvv1240)
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Succ(vvv9860), vvv987) → new_primQuotInt79(vvv982, vvv983, vvv984, vvv9850, vvv9860, vvv987)
new_primQuotInt86(vvv982, vvv983, vvv984, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Zero)) → new_primQuotInt85(vvv982, vvv984, vvv983)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Zero, vvv987) → new_primQuotInt86(vvv982, vvv983, vvv984, vvv987)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Succ(vvv98700))) → new_primQuotInt80(vvv982, Succ(vvv983), vvv98700, vvv984, Succ(vvv983))
new_primQuotInt82(vvv1236, vvv1239, vvv1240, vvv1246) → new_primQuotInt88(vvv1236, vvv1239, vvv1240, vvv1246)
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Zero), vvv888) → new_primQuotInt81(vvv870, vvv8720)
new_primQuotInt80(vvv1236, Succ(vvv12370), Zero, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, Pos(Zero))
new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt81(vvv870, vvv8720) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, Pos(Zero))
new_primQuotInt80(vvv1236, Succ(vvv12370), Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt80(vvv1236, vvv12370, vvv12380, vvv1239, vvv1240)
new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Succ(vvv8720), vvv875, vvv888) → new_primQuotInt79(vvv870, vvv88900, Succ(vvv8720), vvv88900, vvv8720, vvv875)
new_primQuotInt87(vvv1236, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Neg(vvv9870)) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt88(vvv115, vvv2200, vvv1160, vvv272) → new_primQuotInt78(vvv115, Succ(vvv2200), vvv1160, vvv272, Succ(vvv2200))
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Zero, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Neg(vvv8750), vvv888) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt82(vvv1236, vvv1239, vvv1240, vvv1246) → new_primQuotInt88(vvv1236, vvv1239, vvv1240, vvv1246) we obtained the following new rules:

new_primQuotInt82(z0, z2, z3, Pos(Zero)) → new_primQuotInt88(z0, z2, z3, Pos(Zero))
new_primQuotInt82(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt82(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt88(z0, Succ(z1), Zero, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
QDP
                                                                              ↳ Instantiation
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Succ(vvv87500)), vvv888) → new_primQuotInt80(vvv870, Zero, vvv87500, Succ(vvv8720), Zero)
new_primQuotInt82(z0, z2, z3, Pos(Zero)) → new_primQuotInt88(z0, z2, z3, Pos(Zero))
new_primQuotInt82(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt80(vvv1236, Zero, Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt87(vvv1236, vvv1239, vvv1240)
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Succ(vvv9860), vvv987) → new_primQuotInt79(vvv982, vvv983, vvv984, vvv9850, vvv9860, vvv987)
new_primQuotInt86(vvv982, vvv983, vvv984, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Zero)) → new_primQuotInt85(vvv982, vvv984, vvv983)
new_primQuotInt82(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt88(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Succ(vvv98700))) → new_primQuotInt80(vvv982, Succ(vvv983), vvv98700, vvv984, Succ(vvv983))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Zero, vvv987) → new_primQuotInt86(vvv982, vvv983, vvv984, vvv987)
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Zero), vvv888) → new_primQuotInt81(vvv870, vvv8720)
new_primQuotInt80(vvv1236, Succ(vvv12370), Zero, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, Pos(Zero))
new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt81(vvv870, vvv8720) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, Pos(Zero))
new_primQuotInt80(vvv1236, Succ(vvv12370), Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt80(vvv1236, vvv12370, vvv12380, vvv1239, vvv1240)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Neg(vvv9870)) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt87(vvv1236, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, Pos(Zero))
new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Succ(vvv8720), vvv875, vvv888) → new_primQuotInt79(vvv870, vvv88900, Succ(vvv8720), vvv88900, vvv8720, vvv875)
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Neg(vvv8750), vvv888) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Zero, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt88(vvv115, vvv2200, vvv1160, vvv272) → new_primQuotInt78(vvv115, Succ(vvv2200), vvv1160, vvv272, Succ(vvv2200))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt88(vvv115, vvv2200, vvv1160, vvv272) → new_primQuotInt78(vvv115, Succ(vvv2200), vvv1160, vvv272, Succ(vvv2200)) we obtained the following new rules:

new_primQuotInt88(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt78(z0, Succ(Succ(z1)), Zero, Pos(Zero), Succ(Succ(z1)))
new_primQuotInt88(z0, z1, z2, Pos(Zero)) → new_primQuotInt78(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt78(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
QDP
                                                                                  ↳ DependencyGraphProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Succ(vvv87500)), vvv888) → new_primQuotInt80(vvv870, Zero, vvv87500, Succ(vvv8720), Zero)
new_primQuotInt88(z0, z1, z2, Pos(Zero)) → new_primQuotInt78(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt82(z0, z2, z3, Pos(Zero)) → new_primQuotInt88(z0, z2, z3, Pos(Zero))
new_primQuotInt82(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt80(vvv1236, Zero, Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt87(vvv1236, vvv1239, vvv1240)
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Succ(vvv9860), vvv987) → new_primQuotInt79(vvv982, vvv983, vvv984, vvv9850, vvv9860, vvv987)
new_primQuotInt86(vvv982, vvv983, vvv984, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Zero)) → new_primQuotInt85(vvv982, vvv984, vvv983)
new_primQuotInt82(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt88(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Zero, vvv987) → new_primQuotInt86(vvv982, vvv983, vvv984, vvv987)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Succ(vvv98700))) → new_primQuotInt80(vvv982, Succ(vvv983), vvv98700, vvv984, Succ(vvv983))
new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt78(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Zero), vvv888) → new_primQuotInt81(vvv870, vvv8720)
new_primQuotInt88(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt78(z0, Succ(Succ(z1)), Zero, Pos(Zero), Succ(Succ(z1)))
new_primQuotInt80(vvv1236, Succ(vvv12370), Zero, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, Pos(Zero))
new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt81(vvv870, vvv8720) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, Pos(Zero))
new_primQuotInt80(vvv1236, Succ(vvv12370), Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt80(vvv1236, vvv12370, vvv12380, vvv1239, vvv1240)
new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Succ(vvv8720), vvv875, vvv888) → new_primQuotInt79(vvv870, vvv88900, Succ(vvv8720), vvv88900, vvv8720, vvv875)
new_primQuotInt87(vvv1236, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Neg(vvv9870)) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Zero, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Neg(vvv8750), vvv888) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
QDP
                                                                                      ↳ QDPOrderProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Succ(vvv87500)), vvv888) → new_primQuotInt80(vvv870, Zero, vvv87500, Succ(vvv8720), Zero)
new_primQuotInt82(z0, z2, z3, Pos(Zero)) → new_primQuotInt88(z0, z2, z3, Pos(Zero))
new_primQuotInt88(z0, z1, z2, Pos(Zero)) → new_primQuotInt78(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt82(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt80(vvv1236, Zero, Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt87(vvv1236, vvv1239, vvv1240)
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Succ(vvv9860), vvv987) → new_primQuotInt79(vvv982, vvv983, vvv984, vvv9850, vvv9860, vvv987)
new_primQuotInt86(vvv982, vvv983, vvv984, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Zero)) → new_primQuotInt85(vvv982, vvv984, vvv983)
new_primQuotInt82(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt88(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Zero, vvv987) → new_primQuotInt86(vvv982, vvv983, vvv984, vvv987)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Succ(vvv98700))) → new_primQuotInt80(vvv982, Succ(vvv983), vvv98700, vvv984, Succ(vvv983))
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Zero), vvv888) → new_primQuotInt81(vvv870, vvv8720)
new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt78(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt80(vvv1236, Succ(vvv12370), Zero, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, Pos(Zero))
new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt81(vvv870, vvv8720) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, Pos(Zero))
new_primQuotInt80(vvv1236, Succ(vvv12370), Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt80(vvv1236, vvv12370, vvv12380, vvv1239, vvv1240)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Neg(vvv9870)) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt87(vvv1236, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, Pos(Zero))
new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Succ(vvv8720), vvv875, vvv888) → new_primQuotInt79(vvv870, vvv88900, Succ(vvv8720), vvv88900, vvv8720, vvv875)
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Zero, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Neg(vvv8750), vvv888) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, Pos(Zero))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Neg(vvv9870)) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Neg(vvv8750), vvv888) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, Pos(Zero))
The remaining pairs can at least be oriented weakly.

new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Succ(vvv87500)), vvv888) → new_primQuotInt80(vvv870, Zero, vvv87500, Succ(vvv8720), Zero)
new_primQuotInt82(z0, z2, z3, Pos(Zero)) → new_primQuotInt88(z0, z2, z3, Pos(Zero))
new_primQuotInt88(z0, z1, z2, Pos(Zero)) → new_primQuotInt78(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt82(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt80(vvv1236, Zero, Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt87(vvv1236, vvv1239, vvv1240)
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Succ(vvv9860), vvv987) → new_primQuotInt79(vvv982, vvv983, vvv984, vvv9850, vvv9860, vvv987)
new_primQuotInt86(vvv982, vvv983, vvv984, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Zero)) → new_primQuotInt85(vvv982, vvv984, vvv983)
new_primQuotInt82(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt88(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Zero, vvv987) → new_primQuotInt86(vvv982, vvv983, vvv984, vvv987)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Succ(vvv98700))) → new_primQuotInt80(vvv982, Succ(vvv983), vvv98700, vvv984, Succ(vvv983))
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Zero), vvv888) → new_primQuotInt81(vvv870, vvv8720)
new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt78(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt80(vvv1236, Succ(vvv12370), Zero, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, Pos(Zero))
new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt81(vvv870, vvv8720) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, Pos(Zero))
new_primQuotInt80(vvv1236, Succ(vvv12370), Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt80(vvv1236, vvv12370, vvv12380, vvv1239, vvv1240)
new_primQuotInt87(vvv1236, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, Pos(Zero))
new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Succ(vvv8720), vvv875, vvv888) → new_primQuotInt79(vvv870, vvv88900, Succ(vvv8720), vvv88900, vvv8720, vvv875)
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Zero, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
Used ordering: Polynomial interpretation [25]:

POL(Neg(x1)) = 1   
POL(Pos(x1)) = 0   
POL(Succ(x1)) = 0   
POL(Zero) = 0   
POL(new_primMinusNatS2(x1, x2)) = 0   
POL(new_primQuotInt78(x1, x2, x3, x4, x5)) = x4   
POL(new_primQuotInt79(x1, x2, x3, x4, x5, x6)) = x6   
POL(new_primQuotInt80(x1, x2, x3, x4, x5)) = 0   
POL(new_primQuotInt81(x1, x2)) = 0   
POL(new_primQuotInt82(x1, x2, x3, x4)) = 0   
POL(new_primQuotInt85(x1, x2, x3)) = 0   
POL(new_primQuotInt86(x1, x2, x3, x4)) = x4   
POL(new_primQuotInt87(x1, x2, x3)) = 0   
POL(new_primQuotInt88(x1, x2, x3, x4)) = 0   

The following usable rules [17] were oriented: none



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
QDP
                                                                                          ↳ QDPOrderProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Succ(vvv87500)), vvv888) → new_primQuotInt80(vvv870, Zero, vvv87500, Succ(vvv8720), Zero)
new_primQuotInt82(z0, z2, z3, Pos(Zero)) → new_primQuotInt88(z0, z2, z3, Pos(Zero))
new_primQuotInt88(z0, z1, z2, Pos(Zero)) → new_primQuotInt78(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt82(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt80(vvv1236, Zero, Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt87(vvv1236, vvv1239, vvv1240)
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Succ(vvv9860), vvv987) → new_primQuotInt79(vvv982, vvv983, vvv984, vvv9850, vvv9860, vvv987)
new_primQuotInt86(vvv982, vvv983, vvv984, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Zero)) → new_primQuotInt85(vvv982, vvv984, vvv983)
new_primQuotInt82(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt88(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Zero, vvv987) → new_primQuotInt86(vvv982, vvv983, vvv984, vvv987)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Succ(vvv98700))) → new_primQuotInt80(vvv982, Succ(vvv983), vvv98700, vvv984, Succ(vvv983))
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Zero), vvv888) → new_primQuotInt81(vvv870, vvv8720)
new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt78(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt80(vvv1236, Succ(vvv12370), Zero, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, Pos(Zero))
new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt81(vvv870, vvv8720) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, Pos(Zero))
new_primQuotInt80(vvv1236, Succ(vvv12370), Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt80(vvv1236, vvv12370, vvv12380, vvv1239, vvv1240)
new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Succ(vvv8720), vvv875, vvv888) → new_primQuotInt79(vvv870, vvv88900, Succ(vvv8720), vvv88900, vvv8720, vvv875)
new_primQuotInt87(vvv1236, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Zero, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Succ(vvv87500)), vvv888) → new_primQuotInt80(vvv870, Zero, vvv87500, Succ(vvv8720), Zero)
new_primQuotInt80(vvv1236, Zero, Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt87(vvv1236, vvv1239, vvv1240)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Succ(vvv98700))) → new_primQuotInt80(vvv982, Succ(vvv983), vvv98700, vvv984, Succ(vvv983))
new_primQuotInt80(vvv1236, Succ(vvv12370), Succ(vvv12380), vvv1239, vvv1240) → new_primQuotInt80(vvv1236, vvv12370, vvv12380, vvv1239, vvv1240)
The remaining pairs can at least be oriented weakly.

new_primQuotInt82(z0, z2, z3, Pos(Zero)) → new_primQuotInt88(z0, z2, z3, Pos(Zero))
new_primQuotInt88(z0, z1, z2, Pos(Zero)) → new_primQuotInt78(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt82(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Succ(vvv9860), vvv987) → new_primQuotInt79(vvv982, vvv983, vvv984, vvv9850, vvv9860, vvv987)
new_primQuotInt86(vvv982, vvv983, vvv984, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Zero)) → new_primQuotInt85(vvv982, vvv984, vvv983)
new_primQuotInt82(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt88(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Zero, vvv987) → new_primQuotInt86(vvv982, vvv983, vvv984, vvv987)
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Zero), vvv888) → new_primQuotInt81(vvv870, vvv8720)
new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt78(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt80(vvv1236, Succ(vvv12370), Zero, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, Pos(Zero))
new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt81(vvv870, vvv8720) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, Pos(Zero))
new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Succ(vvv8720), vvv875, vvv888) → new_primQuotInt79(vvv870, vvv88900, Succ(vvv8720), vvv88900, vvv8720, vvv875)
new_primQuotInt87(vvv1236, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Zero, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
Used ordering: Polynomial interpretation [25]:

POL(Pos(x1)) = x1   
POL(Succ(x1)) = 1 + x1   
POL(Zero) = 0   
POL(new_primMinusNatS2(x1, x2)) = 0   
POL(new_primQuotInt78(x1, x2, x3, x4, x5)) = x4   
POL(new_primQuotInt79(x1, x2, x3, x4, x5, x6)) = x6   
POL(new_primQuotInt80(x1, x2, x3, x4, x5)) = x3   
POL(new_primQuotInt81(x1, x2)) = 0   
POL(new_primQuotInt82(x1, x2, x3, x4)) = 0   
POL(new_primQuotInt85(x1, x2, x3)) = 0   
POL(new_primQuotInt86(x1, x2, x3, x4)) = x4   
POL(new_primQuotInt87(x1, x2, x3)) = 0   
POL(new_primQuotInt88(x1, x2, x3, x4)) = 0   

The following usable rules [17] were oriented: none



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ QDPOrderProof
QDP
                                                                                              ↳ DependencyGraphProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt82(z0, z2, z3, Pos(Zero)) → new_primQuotInt88(z0, z2, z3, Pos(Zero))
new_primQuotInt88(z0, z1, z2, Pos(Zero)) → new_primQuotInt78(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt82(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Succ(vvv9860), vvv987) → new_primQuotInt79(vvv982, vvv983, vvv984, vvv9850, vvv9860, vvv987)
new_primQuotInt86(vvv982, vvv983, vvv984, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Zero)) → new_primQuotInt85(vvv982, vvv984, vvv983)
new_primQuotInt82(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt88(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Zero, vvv987) → new_primQuotInt86(vvv982, vvv983, vvv984, vvv987)
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Zero), vvv888) → new_primQuotInt81(vvv870, vvv8720)
new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt78(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt80(vvv1236, Succ(vvv12370), Zero, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, Pos(Zero))
new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt81(vvv870, vvv8720) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, Pos(Zero))
new_primQuotInt87(vvv1236, vvv1239, vvv1240) → new_primQuotInt82(vvv1236, vvv1239, vvv1240, Pos(Zero))
new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Succ(vvv8720), vvv875, vvv888) → new_primQuotInt79(vvv870, vvv88900, Succ(vvv8720), vvv88900, vvv8720, vvv875)
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Zero, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 2 less nodes.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ QDPOrderProof
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
QDP
                                                                                                  ↳ Instantiation
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt88(z0, z1, z2, Pos(Zero)) → new_primQuotInt78(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt82(z0, z2, z3, Pos(Zero)) → new_primQuotInt88(z0, z2, z3, Pos(Zero))
new_primQuotInt82(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Succ(vvv9860), vvv987) → new_primQuotInt79(vvv982, vvv983, vvv984, vvv9850, vvv9860, vvv987)
new_primQuotInt86(vvv982, vvv983, vvv984, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Zero)) → new_primQuotInt85(vvv982, vvv984, vvv983)
new_primQuotInt82(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt88(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Zero, vvv987) → new_primQuotInt86(vvv982, vvv983, vvv984, vvv987)
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Zero), vvv888) → new_primQuotInt81(vvv870, vvv8720)
new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt78(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt81(vvv870, vvv8720) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, Pos(Zero))
new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Succ(vvv8720), vvv875, vvv888) → new_primQuotInt79(vvv870, vvv88900, Succ(vvv8720), vvv88900, vvv8720, vvv875)
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Zero, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt82(z0, z2, z3, Pos(Zero)) → new_primQuotInt88(z0, z2, z3, Pos(Zero)) we obtained the following new rules:

new_primQuotInt82(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt82(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt88(z0, Succ(z1), Zero, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ QDPOrderProof
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
QDP
                                                                                                      ↳ Instantiation
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt88(z0, z1, z2, Pos(Zero)) → new_primQuotInt78(z0, Succ(z1), z2, Pos(Zero), Succ(z1))
new_primQuotInt82(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Succ(vvv9860), vvv987) → new_primQuotInt79(vvv982, vvv983, vvv984, vvv9850, vvv9860, vvv987)
new_primQuotInt86(vvv982, vvv983, vvv984, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Zero)) → new_primQuotInt85(vvv982, vvv984, vvv983)
new_primQuotInt82(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt88(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Zero, vvv987) → new_primQuotInt86(vvv982, vvv983, vvv984, vvv987)
new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt78(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Zero), vvv888) → new_primQuotInt81(vvv870, vvv8720)
new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt81(vvv870, vvv8720) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, Pos(Zero))
new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Succ(vvv8720), vvv875, vvv888) → new_primQuotInt79(vvv870, vvv88900, Succ(vvv8720), vvv88900, vvv8720, vvv875)
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Zero, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt88(z0, z1, z2, Pos(Zero)) → new_primQuotInt78(z0, Succ(z1), z2, Pos(Zero), Succ(z1)) we obtained the following new rules:

new_primQuotInt88(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt78(z0, Succ(Succ(z1)), Zero, Pos(Zero), Succ(Succ(z1)))
new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt78(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ QDPOrderProof
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
QDP
                                                                                                          ↳ DependencyGraphProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt82(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Succ(vvv9860), vvv987) → new_primQuotInt79(vvv982, vvv983, vvv984, vvv9850, vvv9860, vvv987)
new_primQuotInt86(vvv982, vvv983, vvv984, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Zero)) → new_primQuotInt85(vvv982, vvv984, vvv983)
new_primQuotInt82(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt88(z0, Succ(z1), Zero, Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Zero, vvv987) → new_primQuotInt86(vvv982, vvv983, vvv984, vvv987)
new_primQuotInt78(vvv870, Succ(Zero), Succ(vvv8720), Pos(Zero), vvv888) → new_primQuotInt81(vvv870, vvv8720)
new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt78(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt88(z0, Succ(z1), Zero, Pos(Zero)) → new_primQuotInt78(z0, Succ(Succ(z1)), Zero, Pos(Zero), Succ(Succ(z1)))
new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt81(vvv870, vvv8720) → new_primQuotInt82(vvv870, Succ(vvv8720), Zero, Pos(Zero))
new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Succ(vvv8720), vvv875, vvv888) → new_primQuotInt79(vvv870, vvv88900, Succ(vvv8720), vvv88900, vvv8720, vvv875)
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Zero, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 4 less nodes.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ QDPOrderProof
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
QDP
                                                                                                              ↳ QDPOrderProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt82(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Succ(vvv9860), vvv987) → new_primQuotInt79(vvv982, vvv983, vvv984, vvv9850, vvv9860, vvv987)
new_primQuotInt86(vvv982, vvv983, vvv984, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Zero)) → new_primQuotInt85(vvv982, vvv984, vvv983)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Zero, vvv987) → new_primQuotInt86(vvv982, vvv983, vvv984, vvv987)
new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Succ(vvv8720), vvv875, vvv888) → new_primQuotInt79(vvv870, vvv88900, Succ(vvv8720), vvv88900, vvv8720, vvv875)
new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt78(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Zero, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_primQuotInt86(vvv982, vvv983, vvv984, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Zero, vvv987) → new_primQuotInt78(vvv982, new_primMinusNatS2(Succ(vvv983), vvv984), vvv984, vvv987, new_primMinusNatS2(Succ(vvv983), vvv984))
The remaining pairs can at least be oriented weakly.

new_primQuotInt82(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Succ(vvv9860), vvv987) → new_primQuotInt79(vvv982, vvv983, vvv984, vvv9850, vvv9860, vvv987)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Zero)) → new_primQuotInt85(vvv982, vvv984, vvv983)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Zero, vvv987) → new_primQuotInt86(vvv982, vvv983, vvv984, vvv987)
new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Succ(vvv8720), vvv875, vvv888) → new_primQuotInt79(vvv870, vvv88900, Succ(vvv8720), vvv88900, vvv8720, vvv875)
new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt78(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
Used ordering: Matrix interpretation [3]:
Non-tuple symbols:
M( Succ(x1) ) =
/1\
\0/
+
/00\
\11/
·x1

M( new_primMinusNatS2(x1, x2) ) =
/0\
\0/
+
/00\
\01/
·x1+
/01\
\00/
·x2

M( Zero ) =
/0\
\1/

M( Pos(x1) ) =
/0\
\1/
+
/00\
\00/
·x1

Tuple symbols:
M( new_primQuotInt88(x1, ..., x4) ) = 1+
[0,0]
·x1+
[1,1]
·x2+
[0,1]
·x3+
[0,0]
·x4

M( new_primQuotInt85(x1, ..., x3) ) = 1+
[0,0]
·x1+
[1,1]
·x2+
[1,1]
·x3

M( new_primQuotInt78(x1, ..., x5) ) = 0+
[0,0]
·x1+
[0,1]
·x2+
[1,1]
·x3+
[0,0]
·x4+
[0,0]
·x5

M( new_primQuotInt86(x1, ..., x4) ) = 1+
[0,0]
·x1+
[1,1]
·x2+
[1,1]
·x3+
[0,0]
·x4

M( new_primQuotInt79(x1, ..., x6) ) = 1+
[0,0]
·x1+
[1,1]
·x2+
[1,1]
·x3+
[0,0]
·x4+
[0,0]
·x5+
[0,0]
·x6

M( new_primQuotInt82(x1, ..., x4) ) = 0+
[0,0]
·x1+
[1,1]
·x2+
[0,1]
·x3+
[0,1]
·x4


Matrix type:
We used a basic matrix type which is not further parametrizeable.


As matrix orders are CE-compatible, we used usable rules w.r.t. argument filtering in the order.
The following usable rules [17] were oriented:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ QDPOrderProof
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ QDPOrderProof
QDP
                                                                                                                  ↳ DependencyGraphProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt82(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Succ(vvv9860), vvv987) → new_primQuotInt79(vvv982, vvv983, vvv984, vvv9850, vvv9860, vvv987)
new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Zero)) → new_primQuotInt85(vvv982, vvv984, vvv983)
new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Succ(vvv8720), vvv875, vvv888) → new_primQuotInt79(vvv870, vvv88900, Succ(vvv8720), vvv88900, vvv8720, vvv875)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Zero, vvv987) → new_primQuotInt86(vvv982, vvv983, vvv984, vvv987)
new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt78(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ QDPOrderProof
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ QDPOrderProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
QDP
                                                                                                                      ↳ UsableRulesProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt82(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Succ(vvv9860), vvv987) → new_primQuotInt79(vvv982, vvv983, vvv984, vvv9850, vvv9860, vvv987)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Zero)) → new_primQuotInt85(vvv982, vvv984, vvv983)
new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Succ(vvv8720), vvv875, vvv888) → new_primQuotInt79(vvv870, vvv88900, Succ(vvv8720), vvv88900, vvv8720, vvv875)
new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt78(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vvv75100), Zero) → Succ(vvv75100)
new_primMinusNatS2(Succ(vvv75100), Succ(vvv7520)) → new_primMinusNatS2(vvv75100, vvv7520)
new_primMinusNatS2(Zero, Succ(vvv7520)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ QDPOrderProof
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ QDPOrderProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ UsableRulesProof
QDP
                                                                                                                          ↳ QReductionProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt82(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Succ(vvv9860), vvv987) → new_primQuotInt79(vvv982, vvv983, vvv984, vvv9850, vvv9860, vvv987)
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Zero)) → new_primQuotInt85(vvv982, vvv984, vvv983)
new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Succ(vvv8720), vvv875, vvv888) → new_primQuotInt79(vvv870, vvv88900, Succ(vvv8720), vvv88900, vvv8720, vvv875)
new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt78(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))

R is empty.
The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ QDPOrderProof
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ QDPOrderProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ UsableRulesProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ QReductionProof
QDP
                                                                                                                              ↳ Instantiation
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt82(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Succ(vvv9860), vvv987) → new_primQuotInt79(vvv982, vvv983, vvv984, vvv9850, vvv9860, vvv987)
new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Zero)) → new_primQuotInt85(vvv982, vvv984, vvv983)
new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Succ(vvv8720), vvv875, vvv888) → new_primQuotInt79(vvv870, vvv88900, Succ(vvv8720), vvv88900, vvv8720, vvv875)
new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt78(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_primQuotInt78(vvv870, Succ(Succ(vvv88900)), Succ(vvv8720), vvv875, vvv888) → new_primQuotInt79(vvv870, vvv88900, Succ(vvv8720), vvv88900, vvv8720, vvv875) we obtained the following new rules:

new_primQuotInt78(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt79(z0, x1, Succ(z2), x1, z2, Pos(Zero))



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ QDPOrderProof
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ QDPOrderProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ UsableRulesProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ QReductionProof
                                                                                                                            ↳ QDP
                                                                                                                              ↳ Instantiation
QDP
                                                                                                                                  ↳ NonInfProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt82(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Succ(vvv9860), vvv987) → new_primQuotInt79(vvv982, vvv983, vvv984, vvv9850, vvv9860, vvv987)
new_primQuotInt78(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt79(z0, x1, Succ(z2), x1, z2, Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Zero)) → new_primQuotInt85(vvv982, vvv984, vvv983)
new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt78(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The DP Problem is simplified using the Induction Calculus [18] with the following steps:
Note that final constraints are written in bold face.


For Pair new_primQuotInt82(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero)) the following chains were created:




For Pair new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero)) the following chains were created:




For Pair new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Succ(vvv9860), vvv987) → new_primQuotInt79(vvv982, vvv983, vvv984, vvv9850, vvv9860, vvv987) the following chains were created:




For Pair new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Zero)) → new_primQuotInt85(vvv982, vvv984, vvv983) the following chains were created:




For Pair new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt78(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1)) the following chains were created:




For Pair new_primQuotInt78(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt79(z0, x1, Succ(z2), x1, z2, Pos(Zero)) the following chains were created:




To summarize, we get the following constraints P for the following pairs.



The constraints for P> respective Pbound are constructed from P where we just replace every occurence of "t ≥ s" in P by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for Pbound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation [18]:

POL(Pos(x1)) = 0   
POL(Succ(x1)) = 1 + x1   
POL(Zero) = 0   
POL(c) = -1   
POL(new_primQuotInt78(x1, x2, x3, x4, x5)) = -1 + x1 + x2 + x3 + x4 - x5   
POL(new_primQuotInt79(x1, x2, x3, x4, x5, x6)) = x1 + x2 - x4 + x5 - x6   
POL(new_primQuotInt82(x1, x2, x3, x4)) = -1 + x1 + x3 - x4   
POL(new_primQuotInt85(x1, x2, x3)) = x1 + x3   
POL(new_primQuotInt88(x1, x2, x3, x4)) = -1 + x1 + x3 - x4   

The following pairs are in P>:

new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Zero)) → new_primQuotInt85(vvv982, vvv984, vvv983)
The following pairs are in Pbound:

new_primQuotInt82(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Zero, Succ(vvv9860), Pos(Zero)) → new_primQuotInt85(vvv982, vvv984, vvv983)
new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt78(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))
new_primQuotInt78(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt79(z0, x1, Succ(z2), x1, z2, Pos(Zero))
There are no usable rules

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ QDPOrderProof
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ QDPOrderProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ UsableRulesProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ QReductionProof
                                                                                                                            ↳ QDP
                                                                                                                              ↳ Instantiation
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ NonInfProof
QDP
                                                                                                                                      ↳ DependencyGraphProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt82(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero))
new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Succ(vvv9860), vvv987) → new_primQuotInt79(vvv982, vvv983, vvv984, vvv9850, vvv9860, vvv987)
new_primQuotInt85(vvv982, vvv984, vvv983) → new_primQuotInt82(vvv982, vvv984, Succ(vvv983), Pos(Zero))
new_primQuotInt78(z0, Succ(Succ(x1)), Succ(z2), Pos(Zero), Succ(Succ(x1))) → new_primQuotInt79(z0, x1, Succ(z2), x1, z2, Pos(Zero))
new_primQuotInt88(z0, z1, Succ(z2), Pos(Zero)) → new_primQuotInt78(z0, Succ(z1), Succ(z2), Pos(Zero), Succ(z1))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 4 less nodes.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ Rewriting
                                                    ↳ QDP
                                                      ↳ Rewriting
                                                        ↳ QDP
                                                          ↳ Rewriting
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ UsableRulesProof
                                                                    ↳ QDP
                                                                      ↳ QReductionProof
                                                                        ↳ QDP
                                                                          ↳ Instantiation
                                                                            ↳ QDP
                                                                              ↳ Instantiation
                                                                                ↳ QDP
                                                                                  ↳ DependencyGraphProof
                                                                                    ↳ QDP
                                                                                      ↳ QDPOrderProof
                                                                                        ↳ QDP
                                                                                          ↳ QDPOrderProof
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Instantiation
                                                                                                    ↳ QDP
                                                                                                      ↳ Instantiation
                                                                                                        ↳ QDP
                                                                                                          ↳ DependencyGraphProof
                                                                                                            ↳ QDP
                                                                                                              ↳ QDPOrderProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ DependencyGraphProof
                                                                                                                    ↳ QDP
                                                                                                                      ↳ UsableRulesProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ QReductionProof
                                                                                                                            ↳ QDP
                                                                                                                              ↳ Instantiation
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ NonInfProof
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
QDP
                                                                                                                                          ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt79(vvv982, vvv983, vvv984, Succ(vvv9850), Succ(vvv9860), vvv987) → new_primQuotInt79(vvv982, vvv983, vvv984, vvv9850, vvv9860, vvv987)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt132(vvv973, vvv974, Succ(vvv9750), Succ(vvv9760), vvv977, vvv978) → new_primQuotInt132(vvv973, vvv974, vvv9750, vvv9760, vvv977, vvv978)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt133(vvv588, Succ(vvv5890), Succ(vvv5900), vvv591, vvv592) → new_primQuotInt133(vvv588, vvv5890, vvv5900, vvv591, vvv592)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt134(vvv813, vvv814, Succ(vvv8150), Succ(vvv8160), vvv817, vvv818) → new_primQuotInt134(vvv813, vvv814, vvv8150, vvv8160, vvv817, vvv818)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt135(vvv569, Succ(vvv5700), Succ(vvv5710), vvv572, vvv573) → new_primQuotInt135(vvv569, vvv5700, vvv5710, vvv572, vvv573)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt136(vvv706, vvv707, Succ(vvv7080), Succ(vvv7090), vvv710, vvv711) → new_primQuotInt136(vvv706, vvv707, vvv7080, vvv7090, vvv710, vvv711)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt137(vvv508, Succ(vvv5090), Succ(vvv5100), vvv511, vvv512) → new_primQuotInt137(vvv508, vvv5090, vvv5100, vvv511, vvv512)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt138(vvv450, vvv451, Succ(vvv4520), Succ(vvv4530), vvv454, vvv455) → new_primQuotInt138(vvv450, vvv451, vvv4520, vvv4530, vvv454, vvv455)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt139(vvv347, Succ(vvv3480), Succ(vvv3490), vvv350, vvv351) → new_primQuotInt139(vvv347, vvv3480, vvv3490, vvv350, vvv351)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt140(vvv71, Succ(vvv22700), Succ(vvv114000), vvv226, vvv72) → new_primQuotInt140(vvv71, vvv22700, vvv114000, vvv226, vvv72)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt141(vvv690, vvv691, Succ(vvv6920), Succ(vvv6930), vvv694, vvv695) → new_primQuotInt141(vvv690, vvv691, vvv6920, vvv6930, vvv694, vvv695)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt142(vvv485, Succ(vvv4860), Succ(vvv4870), vvv488, vvv489) → new_primQuotInt142(vvv485, vvv4860, vvv4870, vvv488, vvv489)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt143(vvv457, vvv458, Succ(vvv4590), Succ(vvv4600), vvv461) → new_primQuotInt143(vvv457, vvv458, vvv4590, vvv4600, vvv461)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt144(vvv330, Succ(vvv3310), Succ(vvv3320), vvv333) → new_primQuotInt144(vvv330, vvv3310, vvv3320, vvv333)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt145(vvv429, vvv430, Succ(vvv4310), Succ(vvv4320), vvv433, vvv434) → new_primQuotInt145(vvv429, vvv430, vvv4310, vvv4320, vvv433, vvv434)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt146(vvv376, Succ(vvv3770), Succ(vvv3780), vvv379, vvv380) → new_primQuotInt146(vvv376, vvv3770, vvv3780, vvv379, vvv380)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt147(vvv274, Succ(vvv2750), Succ(vvv2760), vvv277, vvv278) → new_primQuotInt147(vvv274, vvv2750, vvv2760, vvv277, vvv278)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt148(Succ(vvv1470), Succ(vvv1060), vvv47) → new_primQuotInt148(vvv1470, vvv1060, vvv47)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_reduce2Reduce1(vvv24, vvv25, vvv26, vvv52, vvv51, Succ(vvv5300), Succ(vvv27000)) → new_reduce2Reduce1(vvv24, vvv25, vvv26, vvv52, vvv51, vvv5300, vvv27000)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_reduce2Reduce10(vvv19, vvv20, vvv21, vvv47, vvv46, Succ(vvv4800), Succ(vvv22000)) → new_reduce2Reduce10(vvv19, vvv20, vvv21, vvv47, vvv46, vvv4800, vvv22000)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt149(vvv415, vvv416, Succ(vvv4170), Succ(vvv4180), vvv419, vvv420) → new_primQuotInt149(vvv415, vvv416, vvv4170, vvv4180, vvv419, vvv420)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt150(vvv318, Succ(vvv3190), Succ(vvv3200), vvv321, vvv322) → new_primQuotInt150(vvv318, vvv3190, vvv3200, vvv321, vvv322)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt151(vvv115, Succ(vvv22100), Succ(vvv163000), vvv220, vvv116) → new_primQuotInt151(vvv115, vvv22100, vvv163000, vvv220, vvv116)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt152(vvv115, Succ(vvv1850), Succ(vvv2030), vvv163, vvv116) → new_primQuotInt152(vvv115, vvv1850, vvv2030, vvv163, vvv116)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primQuotInt153(Succ(vvv1610), Succ(vvv1720), vvv116) → new_primQuotInt153(vvv1610, vvv1720, vvv116)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_reduce2Reduce11(vvv29, vvv30, vvv31, vvv72, vvv71, Succ(vvv7300), Succ(vvv32000)) → new_reduce2Reduce11(vvv29, vvv30, vvv31, vvv72, vvv71, vvv7300, vvv32000)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_reduce2Reduce12(vvv8, vvv9, vvv10, vvv116, vvv115, Succ(vvv11700), Succ(vvv12000)) → new_reduce2Reduce12(vvv8, vvv9, vvv10, vvv116, vvv115, vvv11700, vvv12000)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof

Q DP problem:
The TRS P consists of the following rules:

new_genericLength(:(vvv30, vvv31), ba) → new_genericLength(vvv31, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: